<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html id="html">
    <head>
        <title>GC: schema / infinispan-config-5.2.xsd - GrepCode Source</title>
        <meta name="verify-v1" content="oDbHfknRLVnvs+1b/O61iSxPEhVr3O08Fd3QqJ1cGh8="/>
        <meta name="verify-v1" content="d2G+nnw2Xr6jBfde7yNvdZirW9Y6K0fa+56zhEmm6YA="/>
        <meta name="msvalidate.01" content="62B5A32F828BC27E3852FB825A5156E4" />
        <meta name="description" content="schema / infinispan-config-5.2.xsd"/>
        <meta property="fb:app_id" content="143989634057"/>
        <link rel="canonical" href="http://grepcode.com/file/repository.jboss.org/nexus/content/repositories/releases/org.infinispan/infinispan-core/5.2.9.Final/schema/infinispan-config-5.2.xsd"/>
        <link rel="search" type="application/opensearchdescription+xml" title="grepcode.com" href="/static/app/grepcodeosd.xml"/>
        <link rel="icon" type="image/x-icon" href="/static/app/images/favicon.ico"/>

        <link href="/static/app/stylesheet/site.css" rel="stylesheet" type="text/css"/>
        <link href="/static/app/stylesheet/images-sprite.css" rel="stylesheet" type="text/css"/>
        <link href="/static/app/stylesheet/images-site-sprite.css" rel="stylesheet" type="text/css"/>

        <!-- always need these -->
        <script type="text/javascript" src="/static/app/javascript/always.js"></script>

        
        
            <link rel="stylesheet" type="text/css" href="/static/app/libs/yui/treeview/assets/folders.css"/>
            <link rel="stylesheet" type="text/css" href="/static/app/libs/yui/logger/assets/skins/sam/logger.css"/>
            <link rel="stylesheet" type="text/css" href="/static/app/libs/yui/tabview/assets/skins/sam/tabview.css"/>

            <script type="text/javascript" src="/static/app/javascript/yui2.js"></script>
        

        
        
            <script type="text/javascript" src="/static/app/javascript/grepcode.js"></script>
        

        
        
    
<script id="com-grepcode-web-entity-snapshot-ProjectSnapshotChooser-0">
function showSiblings(tLink) {
    var sDiv = tLink.nextSibling;
    while (sDiv.nodeType != 1) { sDiv = sDiv.nextSibling; }

    if (sDiv.style.visibility == "visible") {
        sDiv.style.visibility = "hidden";
    } else {
        var x = getPageOffsetLeft(tLink) - 7;
        var y = getPageOffsetTop(tLink) + tLink.offsetHeight + 5;
        sDiv.style.left = x + "px";
        sDiv.style.top = y + "px";
        sDiv.style.visibility = "visible";
    }
}
</script>
</head>

    <body>
        <div id="header">
            <div class="head-search">
                <div class="head-outer">
                    <div class="head-middle">
                        <div class="head-inner">
                            <div>
    <div class="search-panel">
        <form action="/search">
            <span id="query-container">
                <input id="search-field" type="text" name="query" value=""/>
            </span>
            <input type="hidden" name="n" value=""></input>
            <input type="submit" value="Search"/>
            <span id="search-field-focus-flag" style="display:none;">false</span>
        </form>
    </div>
    <script>
    YAHOO.util.Event.onDOMReady(function() {
        var flag = document.getElementById("search-field-focus-flag");
        if (flag && flag.innerHTML === 'true') {
            document.getElementById("search-field").focus();
        }
    }, null, true)
    </script>
</div>
                        </div>
                    </div>
                </div>
            </div>
            <div id="logo">
                <div class="head-outer">
                    <div class="head-middle">
                        <div class="head-inner">
                            <a href="/"><img src="/static/app/images/logo-rel.gif" alt="Logo" width="200" height="50"/></a>
                        </div>
                    </div>
                </div>
            </div>
            <div class="head-menu head-menu-width">
                <div class="head-outer">
                    <div class="head-middle">
                        <div class="head-inner">
                            <span>
			                <a href="/?st=true">Stack Trace Search</a> |
                            </span>
                            <span>
                            <a href="/eclipse">Eclipse</a> |
                            <a href="/intellij">IntelliJ</a> |
                            <a href="/contact">Contact</a> |
                            <a href="/faq">FAQ</a>
                            </span>
                            
                            <span>
                            |
                            <a href="http://blog.grepcode.com/" rel="nofollow"><img title="Our Blog" alt="Blog" src="/static/app/images/site/blog.png" width="16" height="16" border="0"/></a>
                            <a href="http://twitter.com/grepcode/" rel="nofollow"><img title="Follow us on Twitter" alt="Twitter" src="/static/app/images/site/twitter.png" width="16" height="16" border="0"/></a>
                            <a href="http://www.facebook.com/pages/GrepCode/159698964349" rel="nofollow"><img title="Follow us on FaceBook" alt="FaceBook" src="/static/app/images/site/facebook.png" width="16" height="16" border="0"/></a>
                            </span>
                        </div>
                    </div>
                </div>
            </div>
        </div>
        
            <script type="text/javascript">
                    var gaJsHost = (("https:" == document.location.protocol) ? "https://ssl." : "http://www.");
                    document.write(unescape("%3Cscript src='" + gaJsHost + "google-analytics.com/ga.js' type='text/javascript'%3E%3C/script%3E"));
            </script>
            <script type="text/javascript">
                var pageTracker = _gat._getTracker("UA-7614624-1");
            </script>
        
        
            <script>
                function isGCEnterpriseEdition() {
                    return false;
                }
            </script>
        
        
    <div class="staging-page">
        
<div>
    <script>
    var projectTree = function() {
        var tree, currentIconMode, fileParts;

        function changeIconMode() {
            var newVal = parseInt(this.value);
            if (newVal != currentIconMode) {
                currentIconMode = newVal;
            }
            buildTree();
        }

        function loadNodeData(node, fnLoadComplete)  {
            var entityidParam = encodeURI(node.data.cb_entityid);
            var pathParam = encodeURI(node.data.cb_path);

            var sUrl = "/service/listsourcefiles?" + getEntityType() + "=" + entityidParam + "&path=" + pathParam;

            var callback = {

                success: function(oResponse) {
                    YAHOO.log("XHR transaction was successful.", "info", "example");
                    var oResults = eval("(" + oResponse.responseText + ")");
                    if (YAHOO.lang.isArray(oResults)) {
                        var level = node.data.cb_level + 1;
                        for(var i = 0; i < oResults.length; ++i) {
                            var oRes = oResults[i];
                            if (oRes.t == "d") {
                                var expand = oResults.length == 1;
                                if (isFileStagingPage() && level < fileParts.length) {
                                    if (fileParts[level] == oRes.n) {
                                        expand = true;
                                    }
                                }
                                var tempNode = new YAHOO.widget.TextNode(oRes.n, node, expand);
                                tempNode.data.cb_entityid = node.data.cb_entityid;
                                tempNode.data.cb_path = node.data.cb_path + oRes.n + "/";
                                tempNode.data.cb_level = level;
                            } else if (oRes.t == "f") {
                                if (isFileStagingPage() && (level < fileParts.length) &&
                                    (fileParts[level] == oRes.n) && (fileParts.join("/") == oRes.p)) {
                                    var tempNode = new YAHOO.widget.TextNode(oRes.n, node, false);
                                    tempNode.isLeaf = true;
                                    tempNode.data.cb_level = level;
                                    tempNode.contentStyle = 'current-filename';
                                    // VRB - TODO - Capture div.x and div.y -- scroll div so it is in the center
                                } else {
                                    var tempNode = new YAHOO.widget.TextNode(oRes.n, node, false);
                                    tempNode.href = oRes.l+"?av=f";
                                    tempNode.isLeaf = true;
                                    tempNode.data.cb_level = level;
                                }
                            }
                        }
                    }
                    oResponse.argument.fnLoadComplete();
                },
                failure: function(oResponse) {
                    YAHOO.log("Failed to process XHR transaction.", "info", "example");
                    oResponse.argument.fnLoadComplete();
                },

                argument: {
                    "node": node,
                    "fnLoadComplete": fnLoadComplete
                },

                timeout: 7000
            };

            YAHOO.util.Connect.asyncRequest('GET', sUrl, callback);
        }

        function buildTree() {
            tree = new YAHOO.widget.TreeView("treeDiv");

            tree.setDynamicLoad(loadNodeData, currentIconMode);

            var root = tree.getRoot();

            var entityid = document.getElementById('treerootid_hidden').innerHTML;
            var tempNode = new YAHOO.widget.TextNode(createShortEntityIdLabel(entityid), root, true);
            tempNode.data.cb_entityid=entityid;
            tempNode.data.cb_path="/";
            tempNode.data.cb_level = -1;

            if (isFileStagingPage()) {
                var filePathStart = document.getElementById("entityid_hidden").innerHTML.lastIndexOf('@');
                var filePath = document.getElementById("entityid_hidden").innerHTML.substring(filePathStart + 1);
                fileParts = filePath.split('$');
            }

            tree.draw();
        }


        return {
            init: function() {
                YAHOO.util.Event.on(["mode0", "mode1"], "click", changeIconMode);
                var el = document.getElementById("mode1");
                if (el && el.checked) {
                    currentIconMode = parseInt(el.value);
                } else {
                    currentIconMode = 0;
                }

                buildTree();
            }
        }
    } ();            
    </script>
    <div id="treerootid_hidden" style="display:none">repository.jboss.org$nexus$content$repositories$releases@org.infinispan$infinispan-core@5.2.9.Final</div>
    <div id="entityid_hidden" style="display:none">repository.jboss.org$nexus$content$repositories$releases@org.infinispan$infinispan-core@5.2.9.Final@schema$infinispan-config-5.2.xsd</div>
    <div id="entitytype_hidden" style="display:none">file</div>

    
    
<div class="file-staging-page">
    <div class="entity-header">
        <div class="entity-nav">
            <ul>
                <li><a href="https://repository.jboss.org/nexus/content/repositories/releases/" rel="nofollow" class="external-link">JBoss</a></li>
                <li><span class="entity-nav-delim">/</span></li>
                <li><a href="../../../../../../../../../../project/repository.jboss.org/nexus/content/repositories/releases/org.infinispan/infinispan-core/"><span title="org.infinispan / infinispan-core">org.infinispan / infinispan-core</span></a></li>
                <li><span class="entity-nav-delim">/</span></li>
                <li><span>
    <span>
        <a class="nav" href="../../../../../../../../../../file/repository.jboss.org/nexus/content/repositories/releases/org.infinispan/infinispan-core/5.2.8.Final/schema/infinispan-config-5.2.xsd/"><span><img class='img_base img_jdt_elcl16_backward_nav' src='/static/app/images/1x1.gif' border='0' title='5.2.8.Final' width='16' height='16'></img></span></a>
    </span>
    <a title="Version" href="../../../../../../../../../../snapshot/repository.jboss.org/nexus/content/repositories/releases/org.infinispan/infinispan-core/5.2.9.Final/"><span id="current-snapshot">5.2.9.Final</span></a>
    
        <a href="#" class="snapshots-more"
           onclick="this.blur();showSiblings(this);return false;"><img class='img_base img_jdt_elcl16_next_nav' src='/static/app/images/1x1.gif' border='0' title='5.2.0.Final&nbsp;-&nbsp;5.3.0.Final' width='16' height='16'></img></a>
    
    <div class="snapshots-panel" style="visibility: hidden; z-index:2">
        <div>
            <a href="../../../../../../../../../../file/repository.jboss.org/nexus/content/repositories/releases/org.infinispan/infinispan-core/5.3.0.Final/schema/infinispan-config-5.2.xsd/"><span>5.3.0.Final</span></a>
        </div><div>
            <a href="../../../../../../../../../../file/repository.jboss.org/nexus/content/repositories/releases/org.infinispan/infinispan-core/5.2.14.Final/schema/infinispan-config-5.2.xsd/"><span>5.2.14.Final</span></a>
        </div><div>
            <a href="../../../../../../../../../../file/repository.jboss.org/nexus/content/repositories/releases/org.infinispan/infinispan-core/5.2.13.Final/schema/infinispan-config-5.2.xsd/"><span>5.2.13.Final</span></a>
        </div><div>
            <a href="../../../../../../../../../../file/repository.jboss.org/nexus/content/repositories/releases/org.infinispan/infinispan-core/5.2.12.Final/schema/infinispan-config-5.2.xsd/"><span>5.2.12.Final</span></a>
        </div><div>
            <a href="../../../../../../../../../../file/repository.jboss.org/nexus/content/repositories/releases/org.infinispan/infinispan-core/5.2.11.Final/schema/infinispan-config-5.2.xsd/"><span>5.2.11.Final</span></a>
        </div><div>
            <a href="../../../../../../../../../../file/repository.jboss.org/nexus/content/repositories/releases/org.infinispan/infinispan-core/5.2.10.Final/schema/infinispan-config-5.2.xsd/"><span>5.2.10.Final</span></a>
        </div><div>
            <a href="../../../../../../../../../../file/repository.jboss.org/nexus/content/repositories/releases/org.infinispan/infinispan-core/5.2.9.Final/schema/infinispan-config-5.2.xsd/"><span class="this-snapshot">5.2.9.Final</span></a>
        </div><div>
            <a href="../../../../../../../../../../file/repository.jboss.org/nexus/content/repositories/releases/org.infinispan/infinispan-core/5.2.8.Final/schema/infinispan-config-5.2.xsd/"><span>5.2.8.Final</span></a>
        </div><div>
            <a href="../../../../../../../../../../file/repository.jboss.org/nexus/content/repositories/releases/org.infinispan/infinispan-core/5.2.7.Final/schema/infinispan-config-5.2.xsd/"><span>5.2.7.Final</span></a>
        </div><div>
            <a href="../../../../../../../../../../file/repository.jboss.org/nexus/content/repositories/releases/org.infinispan/infinispan-core/5.2.6.Final/schema/infinispan-config-5.2.xsd/"><span>5.2.6.Final</span></a>
        </div><div>
            <a href="../../../../../../../../../../file/repository.jboss.org/nexus/content/repositories/releases/org.infinispan/infinispan-core/5.2.0.Final/schema/infinispan-config-5.2.xsd/"><span>5.2.0.Final</span></a>
        </div>
    </div>
    <span>
        <a class="nav" href="../../../../../../../../../../file/repository.jboss.org/nexus/content/repositories/releases/org.infinispan/infinispan-core/5.2.10.Final/schema/infinispan-config-5.2.xsd/"><span><img class='img_base img_jdt_elcl16_forward_nav' src='/static/app/images/1x1.gif' border='0' title='5.2.10.Final' width='16' height='16'></img></span></a>
    </span>
</span></li>
                <li><span class="entity-nav-delim">/</span></li>
                <li><span class="entity-name" title="schema / infinispan-config-5.2.xsd">schema / infinispan-config-5.2.xsd</span></li>
            </ul>
            <div class="entity-header-links">
                
            <!-- Google +1 -->
            <div class="g-plusone" data-size="small" data-annotation="none"></div>
        
                
                
                
                
                <span><img class='img_base img_jdt_obj16_source_editor' src='/static/app/images/1x1.gif' border='0' title='View as plain text' width='16' height='16'></img></span>
                <a href="../../../../../../../../../../file_/repository.jboss.org/nexus/content/repositories/releases/org.infinispan/infinispan-core/5.2.9.Final/schema/infinispan-config-5.2.xsd/?v=source" rel="nofollow" title="View as plain text">Raw</a>
                <span><img class='img_base img_jdt_elcl16_save' src='/static/app/images/1x1.gif' border='0' title='Download file' width='16' height='16'></img></span>
                <a href="../../../../../../../../../../file_/repository.jboss.org/nexus/content/repositories/releases/org.infinispan/infinispan-core/5.2.9.Final/schema/infinispan-config-5.2.xsd/?v=source&amp;disposition=attachment" rel="nofollow" title="Download file">Download</a>
                
                
                
                
                
                
            </div>
        </div>
    </div>

    <div id="allviews_hidden" style="display:none"></div>
    <div id="activeview_hidden" style="display:none">f</div>
    <div id="bugs" style="display:none">[]</div>

    <div id="page-mask"></div>
    <div id="snippet-dropdown" class="snippet-dropdown">
        <div id="snippet-close" onclick="hideSnippetDialog();"><img class='img_base img_jdt_elcl16_delete' src='/static/app/images/1x1.gif' border='0' title='Close window' width='16' height='16'></img></div>
        <form id="snippet-form" action="#">
            <div class="snippet-line-input">
                Start line: <input name="snippet_start" type="text" maxlength="8" size="5" value="1" />&nbsp;
                <div class="snippet-spinner-button" onclick="decFromLine();"><img class='img_base img_jdt_obj16_remove_correction' src='/static/app/images/1x1.gif' border='0' title='Previous line' width='16' height='16'></img></div>
                <div class="snippet-spinner-button" onclick="incFromLine();"><img class='img_base img_jdt_elcl16_add' src='/static/app/images/1x1.gif' border='0' title='Next line' width='16' height='16'></img></div>
            </div>
            <div class="snippet-line-input">
                End line: <input name="snippet_end" type="text" maxlength="8" size="5" value="1" />&nbsp;
                <div class="snippet-spinner-button" onclick="decToLine();"><img class='img_base img_jdt_obj16_remove_correction' src='/static/app/images/1x1.gif' border='0' title='Previous line' width='16' height='16'></img></div>
                <div class="snippet-spinner-button" onclick="incToLine();"><img class='img_base img_jdt_elcl16_add' src='/static/app/images/1x1.gif' border='0' title='Next line' width='16' height='16'></img></div>
            </div>
            <div class="snippet-get-button">
                <input type="button" name="snippet_get" value="Create HTML" onclick="fetchSnippet();" />
            </div>
            <br/>
            <p>Snippet Preview</p>
            <div id="snippet-preview"></div>
            <p>Snippet HTML Code</p>
            <textarea name="snippet_html" rows="5" cols="60" readonly="true"></textarea>
        </form>
    </div>
    
    <div id="so-question-panel" class="so-question-panel">
        <div class="so-question-header">
            Stack Overflow Questions
            
        </div>
        
    </div>
    
    <div class="entity-container">
        <div class="file-entity-panel">
            <div id="file-nav-panel" class="file-nav-panel">
                <div class="file-nav-tabs-container">
                    <div id="file-nav-tabs" class="file-nav-tabs yui-skin-sam"></div>
                </div>
            </div>
            <div id="source-view" class="source-view">
                
                
                    <script type="text/javascript">
                    if (isBrowserMSIE()) {
                        document.write("<div style=\"padding: 20px;\">" + get468x60Ad() + "</div>");
                    }
                    </script>
                
                <div><div class='code-panel'><pre>&lt;?xml version=&quot;1.0&quot; encoding=&quot;UTF-8&quot; standalone=&quot;yes&quot;?&gt;
&lt;!--
  ~ Copyright 2012 Red Hat, Inc. and/or its affiliates.
  ~
  ~ This is free software; you can redistribute it and/or modify it
  ~ under the terms of the GNU Lesser General Public License as
  ~ published by the Free Software Foundation; either version 2.1 of
  ~ the License, or (at your option) any later version.
  ~
  ~ This software is distributed in the hope that it will be useful,
  ~ but WITHOUT ANY WARRANTY; without even the implied warranty of
  ~ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  ~ Lesser General Public License for more details.
  ~
  ~ You should have received a copy of the GNU Lesser General Public
  ~ License along with this library; if not, write to the Free Software
  ~ Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  ~ 02110-1301 USA
  --&gt;

&lt;xs:schema attributeFormDefault=&quot;unqualified&quot; elementFormDefault=&quot;qualified&quot; version=&quot;1.0&quot; targetNamespace=&quot;urn:infinispan:config:5.2&quot; xmlns:tns=&quot;urn:infinispan:config:5.2&quot; xmlns:xs=&quot;http://www.w3.org/2001/XMLSchema&quot;&gt;

  &lt;xs:element name=&quot;infinispan&quot;&gt;
    &lt;xs:annotation&gt;
      &lt;xs:documentation&gt;
        Defines the configuration for Infinispan, for the cache manager configuration, for the default cache, and for named caches.
      &lt;/xs:documentation&gt;
    &lt;/xs:annotation&gt;
    &lt;xs:complexType&gt;
        &lt;xs:sequence&gt;
        &lt;xs:element name=&quot;global&quot; minOccurs=&quot;0&quot;&gt;
          &lt;xs:complexType&gt;
            &lt;xs:annotation&gt;
              &lt;xs:documentation&gt;
                Defines global settings shared among all cache instances created by a single CacheManager.
              &lt;/xs:documentation&gt;
            &lt;/xs:annotation&gt;
            &lt;xs:all&gt;
              &lt;xs:element name=&quot;asyncListenerExecutor&quot; type=&quot;tns:executorFactory&quot; minOccurs=&quot;0&quot;&gt;
                &lt;xs:annotation&gt;
                  &lt;xs:documentation&gt;
                    Configuration for the executor service used to emit notifications to asynchronous listeners
                  &lt;/xs:documentation&gt;
                &lt;/xs:annotation&gt;
              &lt;/xs:element&gt;
              &lt;xs:element name=&quot;asyncTransportExecutor&quot; type=&quot;tns:executorFactory&quot; minOccurs=&quot;0&quot;&gt;
                &lt;xs:annotation&gt;
                  &lt;xs:documentation&gt;
                    Configuration for the executor service used for asynchronous work on the Transport, including asynchronous marshalling and Cache 'async operations' such as Cache.putAsync().
                  &lt;/xs:documentation&gt;
                &lt;/xs:annotation&gt;
              &lt;/xs:element&gt;
              &lt;xs:element name=&quot;evictionScheduledExecutor&quot; type=&quot;tns:scheduledExecutorFactory&quot; minOccurs=&quot;0&quot;&gt;
                &lt;xs:annotation&gt;
                  &lt;xs:documentation&gt;
                    Configuration for the scheduled executor service used to periodically run eviction cleanup tasks.
                  &lt;/xs:documentation&gt;
                &lt;/xs:annotation&gt;
              &lt;/xs:element&gt;
              &lt;xs:element name=&quot;replicationQueueScheduledExecutor&quot; type=&quot;tns:scheduledExecutorFactory&quot; minOccurs=&quot;0&quot;&gt;
                &lt;xs:annotation&gt;
                  &lt;xs:documentation&gt;
                    Configuration for the scheduled executor service used to periodically flush replication queues, used if asynchronous clustering is enabled along with useReplQueue being set to true.
                  &lt;/xs:documentation&gt;
                &lt;/xs:annotation&gt;
              &lt;/xs:element&gt;
              &lt;xs:element name=&quot;site&quot; type=&quot;tns:site&quot; minOccurs=&quot;0&quot;&gt;
                &lt;xs:annotation&gt;
                  &lt;xs:documentation&gt;
                    Configuration for the x-site replication.
                  &lt;/xs:documentation&gt;
                &lt;/xs:annotation&gt;
              &lt;/xs:element&gt;
              &lt;xs:element name=&quot;globalJmxStatistics&quot; minOccurs=&quot;0&quot;&gt;
                &lt;xs:annotation&gt;
                  &lt;xs:documentation&gt;
                    This element specifies whether global statistics are gathered and reported via JMX for all caches under this cache manager.
                  &lt;/xs:documentation&gt;
                &lt;/xs:annotation&gt;
                &lt;xs:complexType&gt;
                  &lt;xs:sequence&gt;
                    &lt;xs:element name=&quot;properties&quot; type=&quot;tns:properties&quot; minOccurs=&quot;0&quot;&gt;
                      &lt;xs:annotation&gt;
                        &lt;xs:documentation&gt;
                          Sets properties which are then passed to the MBean Server Lookup implementation specified.
                        &lt;/xs:documentation&gt;
                      &lt;/xs:annotation&gt;
                    &lt;/xs:element&gt;
                  &lt;/xs:sequence&gt;
                  &lt;xs:attribute name=&quot;allowDuplicateDomains&quot; type=&quot;xs:boolean&quot;&gt;
                   &lt;xs:annotation&gt;
                     &lt;xs:documentation&gt;
                       If true, multiple cache manager instances could be configured under the same configured JMX domain. Each cache manager will in practice use a different JMX domain that has been calculated based on the configured one by adding an incrementing index to it.
                     &lt;/xs:documentation&gt;
                   &lt;/xs:annotation&gt;
                  &lt;/xs:attribute&gt;
                  &lt;xs:attribute name=&quot;cacheManagerName&quot; type=&quot;xs:string&quot;&gt;
                   &lt;xs:annotation&gt;
                     &lt;xs:documentation&gt;
                       If JMX statistics are enabled, this property represents the name of this cache manager. It offers the possibility for clients to provide a user-defined name to the cache manager which later can be used to identify the cache manager within a JMX based management tool amongst other cache managers that might be running under the same JVM.
                     &lt;/xs:documentation&gt;
                   &lt;/xs:annotation&gt;
                  &lt;/xs:attribute&gt;
                  &lt;xs:attribute name=&quot;enabled&quot; type=&quot;xs:boolean&quot;&gt;
                    &lt;xs:annotation&gt;
                      &lt;xs:documentation&gt;Enable Global JMX statistics&lt;/xs:documentation&gt;
                    &lt;/xs:annotation&gt;
                  &lt;/xs:attribute&gt;
                  &lt;xs:attribute name=&quot;jmxDomain&quot; type=&quot;xs:string&quot;&gt;
                   &lt;xs:annotation&gt;
                     &lt;xs:documentation&gt;
                       If JMX statistics are enabled then all 'published' JMX objects will appear under this name. This is optional, if not specified an object name will be created for you by default.
                     &lt;/xs:documentation&gt;
                   &lt;/xs:annotation&gt;
                  &lt;/xs:attribute&gt;
                  &lt;xs:attribute name=&quot;mBeanServerLookup&quot; type=&quot;xs:string&quot;&gt;
                   &lt;xs:annotation&gt;
                     &lt;xs:documentation&gt;
                       Class that will attempt to locate a JMX MBean server to bind to
                     &lt;/xs:documentation&gt;
                   &lt;/xs:annotation&gt;
                  &lt;/xs:attribute&gt;
                &lt;/xs:complexType&gt;
              &lt;/xs:element&gt;
              &lt;xs:element name=&quot;transport&quot; minOccurs=&quot;0&quot;&gt;
                &lt;xs:annotation&gt;
                  &lt;xs:documentation&gt;
                    This element configures the transport used for network communications across the cluster.
                  &lt;/xs:documentation&gt;
                &lt;/xs:annotation&gt;
                &lt;xs:complexType&gt;
                  &lt;xs:sequence&gt;
                    &lt;xs:element name=&quot;properties&quot; type=&quot;tns:properties&quot; minOccurs=&quot;0&quot;&gt;
                      &lt;xs:annotation&gt;
                         &lt;xs:documentation&gt;
                            Sets transport properties
                         &lt;/xs:documentation&gt;
                      &lt;/xs:annotation&gt;
                    &lt;/xs:element&gt;
                  &lt;/xs:sequence&gt;
                  &lt;xs:attribute name=&quot;clusterName&quot; type=&quot;xs:string&quot;&gt;
                    &lt;xs:annotation&gt;
                      &lt;xs:documentation&gt;
                         Defines the name of the cluster. Nodes only connect to clusters sharing the same name.
                      &lt;/xs:documentation&gt;
                    &lt;/xs:annotation&gt;
                  &lt;/xs:attribute&gt;
                  &lt;xs:attribute name=&quot;distributedSyncTimeout&quot; type=&quot;xs:long&quot;&gt;
                    &lt;xs:annotation&gt;
                      &lt;xs:documentation&gt;
                        Infinispan uses a distributed lock to maintain a coherent transaction log during state transfer or rehashing which means that only one cache can be doing state transfer or rehashing at the same time. This constraint is in place because more than one cache could be involved in a transaction. This timeout controls the time to wait to acquire acquire a lock on the distributed lock.
                      &lt;/xs:documentation&gt;
                    &lt;/xs:annotation&gt;
                  &lt;/xs:attribute&gt;
                  &lt;xs:attribute name=&quot;machineId&quot; type=&quot;xs:string&quot;&gt;
                    &lt;xs:annotation&gt;
                      &lt;xs:documentation&gt;
                        The id of the machine where this node runs. Visit http://community.jboss.org/wiki/DesigningServerHinting for more information .
                      &lt;/xs:documentation&gt;
                    &lt;/xs:annotation&gt;
                  &lt;/xs:attribute&gt;
                  &lt;xs:attribute name=&quot;nodeName&quot; type=&quot;xs:string&quot;&gt;
                    &lt;xs:annotation&gt;
                      &lt;xs:documentation&gt;
                        Name of the current node. This is a friendly name to make logs, etc. make more sense. Defaults to a combination of host name and a random number (to differentiate multiple nodes on the same host)
                      &lt;/xs:documentation&gt;
                    &lt;/xs:annotation&gt;
                  &lt;/xs:attribute&gt;
                  &lt;xs:attribute name=&quot;rackId&quot; type=&quot;xs:string&quot;&gt;
                    &lt;xs:annotation&gt;
                      &lt;xs:documentation&gt;
                        The id of the rack where this node runs. Visit http://community.jboss.org/wiki/DesigningServerHinting for more information .
                      &lt;/xs:documentation&gt;
                    &lt;/xs:annotation&gt;
                  &lt;/xs:attribute&gt;
                  &lt;xs:attribute name=&quot;siteId&quot; type=&quot;xs:string&quot;&gt;
                    &lt;xs:annotation&gt;
                      &lt;xs:documentation&gt;
                        The id of the site where this node runs. Visit http://community.jboss.org/wiki/DesigningServerHinting for more information .
                      &lt;/xs:documentation&gt;
                    &lt;/xs:annotation&gt;
                  &lt;/xs:attribute&gt;
                  &lt;xs:attribute name=&quot;strictPeerToPeer&quot; type=&quot;xs:boolean&quot;&gt;
                    &lt;xs:annotation&gt;
                      &lt;xs:documentation&gt;
                        If set to true, RPC operations will fail if the named cache does not exist on remote nodes with a NamedCacheNotFoundException. Otherwise, operations will succeed but it will be logged on the caller that the RPC did not succeed on certain nodes due to the named cache not being available.
                      &lt;/xs:documentation&gt;
                    &lt;/xs:annotation&gt;
                  &lt;/xs:attribute&gt;
                  &lt;xs:attribute name=&quot;transportClass&quot; type=&quot;xs:string&quot;&gt;
                    &lt;xs:annotation&gt;
                      &lt;xs:documentation&gt;
                        Class that represents a network transport. Must implement org.infinispan.remoting.transport.Transport
                      &lt;/xs:documentation&gt;
                    &lt;/xs:annotation&gt;
                  &lt;/xs:attribute&gt;
                &lt;/xs:complexType&gt;
              &lt;/xs:element&gt;
              &lt;xs:element name=&quot;serialization&quot; minOccurs=&quot;0&quot;&gt;
                &lt;xs:annotation&gt;
                  &lt;xs:documentation&gt;
                    Configures serialization and marshalling settings.
                  &lt;/xs:documentation&gt;
                &lt;/xs:annotation&gt;
                
                &lt;xs:complexType&gt;
                  &lt;xs:sequence&gt;
                    &lt;xs:element name=&quot;advancedExternalizers&quot; minOccurs=&quot;0&quot;&gt;
                      &lt;xs:annotation&gt;
                        &lt;xs:documentation&gt;
                          Configures custom marshallers.
                        &lt;/xs:documentation&gt;
                      &lt;/xs:annotation&gt;
                        &lt;xs:complexType&gt;
                          &lt;xs:sequence&gt;
                            &lt;xs:element name=&quot;advancedExternalizer&quot; minOccurs=&quot;0&quot; maxOccurs=&quot;unbounded&quot;&gt;
                              &lt;xs:annotation&gt;
                                &lt;xs:documentation&gt;
                                  AdvancedExternalizer provides an alternative way to provide externalizers for marshalling/unmarshalling user defined classes that overcome the deficiencies of the more user-friendly externalizer definition  model explained in Externalizer.
                                &lt;/xs:documentation&gt;
                              &lt;/xs:annotation&gt;
                              &lt;xs:complexType&gt;
                                &lt;xs:attribute name=&quot;externalizerClass&quot; type=&quot;xs:string&quot;&gt;
                                  &lt;xs:annotation&gt;
                                    &lt;xs:documentation&gt;
                                      Class of the custom marshaller
                                    &lt;/xs:documentation&gt;
                                  &lt;/xs:annotation&gt;
                                &lt;/xs:attribute&gt;
                                &lt;xs:attribute name=&quot;id&quot; type=&quot;xs:int&quot;&gt;
                                  &lt;xs:annotation&gt;
                                    &lt;xs:documentation&gt;
                                      Id of the custom marshaller
                                    &lt;/xs:documentation&gt;
                                  &lt;/xs:annotation&gt;
                                &lt;/xs:attribute&gt;
                              &lt;/xs:complexType&gt;
                            &lt;/xs:element&gt;
                          &lt;/xs:sequence&gt;
                        &lt;/xs:complexType&gt;
                    &lt;/xs:element&gt;
                  &lt;/xs:sequence&gt;
                  &lt;xs:attribute name=&quot;marshallerClass&quot; type=&quot;xs:string&quot;&gt;
                   &lt;xs:annotation&gt;
                      &lt;xs:documentation&gt;
                         Fully qualified name of the marshaller to use. It must implement org.infinispan.marshall.StreamingMarshaller
                      &lt;/xs:documentation&gt;
                   &lt;/xs:annotation&gt;
                  &lt;/xs:attribute&gt;
                  &lt;xs:attribute name=&quot;version&quot; type=&quot;xs:string&quot;&gt;
                   &lt;xs:annotation&gt;
                      &lt;xs:documentation&gt;
                         Largest allowable version to use when marshalling internal state. Set this to the lowest version cache instance in your cluster to ensure compatibility of communications. However, setting this too low will mean you lose out on the benefit of improvements in newer versions of the marshaller.
                      &lt;/xs:documentation&gt;
                   &lt;/xs:annotation&gt;
                  &lt;/xs:attribute&gt;
                &lt;/xs:complexType&gt;
              &lt;/xs:element&gt;
              &lt;xs:element name=&quot;shutdown&quot; minOccurs=&quot;0&quot;&gt;
                &lt;xs:annotation&gt;
                  &lt;xs:documentation&gt;
                    This element specifies behavior when the JVM running the cache instance shuts down.
                  &lt;/xs:documentation&gt;
                &lt;/xs:annotation&gt;
                &lt;xs:complexType&gt;
                  &lt;xs:attribute name=&quot;hookBehavior&quot; type=&quot;tns:shutdownHookBehavior&quot;&gt;
                    &lt;xs:annotation&gt;
                      &lt;xs:documentation&gt;
                        Behavior of the JVM shutdown hook registered by the cache
                      &lt;/xs:documentation&gt;
                    &lt;/xs:annotation&gt;
                  &lt;/xs:attribute&gt;
                &lt;/xs:complexType&gt;
              &lt;/xs:element&gt;
              &lt;xs:element name=&quot;modules&quot; minOccurs=&quot;0&quot;&gt;
                &lt;xs:annotation&gt;
                  &lt;xs:documentation&gt;
                    This element contains configuration options for additional modules which affect global configuration
                  &lt;/xs:documentation&gt;
                &lt;/xs:annotation&gt;
                &lt;xs:complexType&gt;
                  &lt;xs:sequence minOccurs=&quot;0&quot; maxOccurs=&quot;unbounded&quot;&gt;
                    &lt;xs:any namespace=&quot;##other&quot;/&gt;
                  &lt;/xs:sequence&gt;
                &lt;/xs:complexType&gt;
              &lt;/xs:element&gt;
            &lt;/xs:all&gt;
          &lt;/xs:complexType&gt;
        &lt;/xs:element&gt;
        &lt;xs:element name=&quot;default&quot; type=&quot;tns:configuration&quot; minOccurs=&quot;0&quot;&gt;
          &lt;xs:annotation&gt;
            &lt;xs:documentation&gt;
              Specifies the default behvaior for all named caches belonging to this cache manager.
            &lt;/xs:documentation&gt;
          &lt;/xs:annotation&gt;
        &lt;/xs:element&gt;
        &lt;xs:element name=&quot;namedCache&quot; type=&quot;tns:configuration&quot; minOccurs=&quot;0&quot; maxOccurs=&quot;unbounded&quot;&gt;
          &lt;xs:annotation&gt;
            &lt;xs:documentation&gt;
              Specify the configuration for a named cache.
            &lt;/xs:documentation&gt;
          &lt;/xs:annotation&gt;
        &lt;/xs:element&gt;
      &lt;/xs:sequence&gt;
    &lt;/xs:complexType&gt;
  &lt;/xs:element&gt;

  &lt;xs:complexType name=&quot;configuration&quot;&gt;
    &lt;xs:all&gt;
      &lt;xs:element name=&quot;locking&quot; minOccurs=&quot;0&quot;&gt;
        &lt;xs:annotation&gt;
          &lt;xs:documentation&gt;
            Defines the local, in-VM locking and concurrency characteristics of the cache.
          &lt;/xs:documentation&gt;
        &lt;/xs:annotation&gt;
        &lt;xs:complexType&gt;
          &lt;xs:attribute name=&quot;concurrencyLevel&quot; type=&quot;xs:int&quot;&gt;
            &lt;xs:annotation&gt;
              &lt;xs:documentation&gt;
                Concurrency level for lock containers. Adjust this value according to the number of concurrent threads interacting with Infinispan. Similar to the concurrencyLevel tuning parameter seen in the JDK's ConcurrentHashMap.
              &lt;/xs:documentation&gt;
            &lt;/xs:annotation&gt;
          &lt;/xs:attribute&gt;
          &lt;xs:attribute name=&quot;isolationLevel&quot; type=&quot;tns:isolationLevel&quot;&gt;
            &lt;xs:annotation&gt;
              &lt;xs:documentation&gt;
                Cache isolation level. Infinispan only supports READ_COMMITTED or REPEATABLE_READ isolation levels. See http://en.wikipedia.org/wiki/Isolation_level'&gt;http://en.wikipedia.org/wiki/Isolation_level for a discussion on isolation levels.
              &lt;/xs:documentation&gt;
            &lt;/xs:annotation&gt;
          &lt;/xs:attribute&gt;
          &lt;xs:attribute name=&quot;lockAcquisitionTimeout&quot; type=&quot;xs:long&quot;&gt;
            &lt;xs:annotation&gt;
              &lt;xs:documentation&gt;
                Maximum time to attempt a particular lock acquisition
              &lt;/xs:documentation&gt;
            &lt;/xs:annotation&gt;
          &lt;/xs:attribute&gt;
          &lt;xs:attribute name=&quot;useLockStriping&quot; type=&quot;xs:boolean&quot;&gt;
            &lt;xs:annotation&gt;
              &lt;xs:documentation&gt;
                If true, a pool of shared locks is maintained for all entries that need to be locked. Otherwise, a lock is created per entry in the cache. Lock striping helps control memory footprint but may reduce concurrency in the system.
              &lt;/xs:documentation&gt;
            &lt;/xs:annotation&gt;
          &lt;/xs:attribute&gt;
          &lt;xs:attribute name=&quot;writeSkewCheck&quot; type=&quot;xs:boolean&quot;&gt;
            &lt;xs:annotation&gt;
              &lt;xs:documentation&gt;
                This setting is only applicable in the case of REPEATABLE_READ. When write skew check is set to false, if the writer at commit time discovers that the working entry and the underlying entry have different versions, the working entry will overwrite the underlying entry. If true, such version conflict - known as a write-skew - will throw an Exception.
              &lt;/xs:documentation&gt;
            &lt;/xs:annotation&gt;
          &lt;/xs:attribute&gt;
          &lt;xs:attribute name=&quot;supportsConcurrentUpdates&quot; type=&quot;xs:boolean&quot;&gt;
            &lt;xs:annotation&gt;
              &lt;xs:documentation&gt;
                  For non-transactional caches only: if set to true(default value) the cache keeps data consistent in the case of concurrent updates. For clustered caches this comes at the cost of an additional RPC, so if you don't expect your application to write data concurrently, disabling this flag increases performance.
              &lt;/xs:documentation&gt;
            &lt;/xs:annotation&gt;
          &lt;/xs:attribute&gt;
        &lt;/xs:complexType&gt;
      &lt;/xs:element&gt;
      &lt;xs:element name=&quot;loaders&quot; minOccurs=&quot;0&quot;&gt;
        &lt;xs:annotation&gt;
          &lt;xs:documentation&gt;
            Configuration for cache loaders and stores.
          &lt;/xs:documentation&gt;
        &lt;/xs:annotation&gt;
        &lt;xs:complexType&gt;
          &lt;xs:sequence&gt;
            &lt;xs:element name=&quot;loader&quot; minOccurs=&quot;0&quot; maxOccurs=&quot;unbounded&quot; type=&quot;tns:customStore&quot;&gt;
              &lt;xs:annotation&gt;
                &lt;xs:documentation&gt;
                  Configuration of a specific cache loader
                &lt;/xs:documentation&gt;
              &lt;/xs:annotation&gt;
            &lt;/xs:element&gt;
            &lt;xs:element name=&quot;store&quot; minOccurs=&quot;0&quot; maxOccurs=&quot;unbounded&quot; type=&quot;tns:customStore&quot;&gt;
              &lt;xs:annotation&gt;
                &lt;xs:documentation&gt;
                  Configuration of a specific cache store
                &lt;/xs:documentation&gt;
              &lt;/xs:annotation&gt;
            &lt;/xs:element&gt;
            &lt;xs:element name=&quot;clusterLoader&quot; minOccurs=&quot;0&quot; maxOccurs=&quot;unbounded&quot; type=&quot;tns:clusterLoader&quot;&gt;
              &lt;xs:annotation&gt;
                &lt;xs:documentation&gt;
                  Configuration of a ClusterCacheLoader
                &lt;/xs:documentation&gt;
              &lt;/xs:annotation&gt;
            &lt;/xs:element&gt;
            &lt;xs:element name=&quot;fileStore&quot; minOccurs=&quot;0&quot; maxOccurs=&quot;unbounded&quot; type=&quot;tns:fileStore&quot;&gt;
              &lt;xs:annotation&gt;
                &lt;xs:documentation&gt;
                  Configuration of a FileCacheStore
                &lt;/xs:documentation&gt;
              &lt;/xs:annotation&gt;
            &lt;/xs:element&gt;
            &lt;xs:any namespace=&quot;##other&quot; minOccurs=&quot;0&quot; maxOccurs=&quot;unbounded&quot; /&gt;
          &lt;/xs:sequence&gt;
          &lt;xs:attribute name=&quot;passivation&quot; type=&quot;xs:boolean&quot;&gt;
            &lt;xs:annotation&gt;
              &lt;xs:documentation&gt;
                If true, data is only written to the cache store when it is evicted from memory, a phenomenon known as 'passivation'. Next time the data is requested, it will be 'activated' which means that data will be brought back to memory and removed from the persistent store. This gives you the ability to 'overflow' to disk, similar to swapping in an operating system. If false, the cache store contains a copy of the contents in memory, so writes to cache result in cache store writes. This essentially gives you a 'write-through' configuration.
              &lt;/xs:documentation&gt;
            &lt;/xs:annotation&gt;
          &lt;/xs:attribute&gt;
          &lt;xs:attribute name=&quot;preload&quot; type=&quot;xs:boolean&quot;&gt;
            &lt;xs:annotation&gt;
              &lt;xs:documentation&gt;
                If true, when the cache starts, data stored in the cache store will be pre-loaded into memory. This is particularly useful when data in the cache store will be needed immediately after startup and you want to avoid cache operations being delayed as a result of loading this data lazily. Can be used to provide a 'warm-cache' on startup, however there is a performance penalty as startup time is affected by this process.
              &lt;/xs:documentation&gt;
            &lt;/xs:annotation&gt;
          &lt;/xs:attribute&gt;
          &lt;xs:attribute name=&quot;shared&quot; type=&quot;xs:boolean&quot;&gt;
            &lt;xs:annotation&gt;
              &lt;xs:documentation&gt;
                This setting should be set to true when multiple cache instances share the same cache store (e.g., multiple nodes in a cluster using a JDBC-based CacheStore pointing to the same, shared database.) Setting this to true avoids multiple cache instances writing the same modification multiple times. If enabled, only the node where the modification originated will write to the cache store. If disabled, each individual cache reacts to a potential remote update by storing the data to the cache store. Note that this could be useful if each individual node has its own cache store - perhaps local on-disk.
              &lt;/xs:documentation&gt;
            &lt;/xs:annotation&gt;
          &lt;/xs:attribute&gt;
        &lt;/xs:complexType&gt;
      &lt;/xs:element&gt;
      &lt;xs:element name=&quot;sites&quot; minOccurs=&quot;0&quot;&gt;
        &lt;xs:annotation&gt;
          &lt;xs:documentation&gt;
            Cache configuration for the x-site replication.
          &lt;/xs:documentation&gt;
        &lt;/xs:annotation&gt;
        &lt;xs:complexType&gt;
          &lt;xs:sequence minOccurs=&quot;0&quot; maxOccurs=&quot;unbounded&quot;&gt;
              &lt;xs:element name=&quot;backups&quot; minOccurs=&quot;0&quot; maxOccurs=&quot;unbounded&quot;&gt;
                  &lt;xs:annotation&gt;
                      &lt;xs:documentation&gt;
                          Configures the list of sites where this cache backups.
                      &lt;/xs:documentation&gt;
                  &lt;/xs:annotation&gt;
                  &lt;xs:complexType&gt;
                      &lt;xs:sequence minOccurs=&quot;0&quot; maxOccurs=&quot;1&quot;&gt;
                          &lt;xs:element name=&quot;backup&quot; minOccurs=&quot;0&quot; maxOccurs=&quot;unbounded&quot; type=&quot;tns:backup&quot;&gt;
                              &lt;xs:annotation&gt;
                                  &lt;xs:documentation&gt;
                                      Configures a specific site where this cache backups data. The name of the backup
                                      must match
                                      a site defined in the &quot;global&quot; section.
                                  &lt;/xs:documentation&gt;
                              &lt;/xs:annotation&gt;
                          &lt;/xs:element&gt;
                      &lt;/xs:sequence&gt;
                  &lt;/xs:complexType&gt;
              &lt;/xs:element&gt;
              &lt;xs:element name=&quot;backupFor&quot; minOccurs=&quot;0&quot; maxOccurs=&quot;1&quot;&gt;
                  &lt;xs:annotation&gt;
                      &lt;xs:documentation&gt;
                          Configures this cache as a backup for a remote cache.
                      &lt;/xs:documentation&gt;
                  &lt;/xs:annotation&gt;
                  &lt;xs:complexType&gt;
                      &lt;xs:attribute name=&quot;remoteCache&quot; type=&quot;xs:string&quot; use=&quot;optional&quot;&gt;
                          &lt;xs:annotation&gt;
                              &lt;xs:documentation&gt;
                                  The name of the remote cache that backups data here.
                              &lt;/xs:documentation&gt;
                          &lt;/xs:annotation&gt;
                      &lt;/xs:attribute&gt;
                      &lt;xs:attribute name=&quot;remoteSite&quot; type=&quot;xs:string&quot; use=&quot;optional&quot;&gt;
                          &lt;xs:annotation&gt;
                              &lt;xs:documentation&gt;
                                  The name of the remote site containing the cache that backups data here.
                              &lt;/xs:documentation&gt;
                          &lt;/xs:annotation&gt;
                      &lt;/xs:attribute&gt;
                  &lt;/xs:complexType&gt;
              &lt;/xs:element&gt;
          &lt;/xs:sequence&gt;
        &lt;/xs:complexType&gt;
      &lt;/xs:element&gt;
      &lt;xs:element name=&quot;transaction&quot; minOccurs=&quot;0&quot;&gt;
        &lt;xs:annotation&gt;
          &lt;xs:documentation&gt;
            Defines transactional (JTA) characteristics of the cache.
          &lt;/xs:documentation&gt;
        &lt;/xs:annotation&gt;
        &lt;xs:complexType&gt;
          &lt;xs:sequence&gt;
            &lt;xs:element name=&quot;recovery&quot; minOccurs=&quot;0&quot;&gt;
              &lt;xs:annotation&gt;
                &lt;xs:documentation&gt;
                  Defines recovery configuration for the cache.
                &lt;/xs:documentation&gt;
              &lt;/xs:annotation&gt;
              &lt;xs:complexType&gt;
                &lt;xs:attribute name=&quot;enabled&quot; type=&quot;xs:boolean&quot; use=&quot;required&quot;&gt;
                  &lt;xs:annotation&gt;
                    &lt;xs:documentation&gt;
                      Enable recovery for this cache.
                    &lt;/xs:documentation&gt;
                  &lt;/xs:annotation&gt;
                &lt;/xs:attribute&gt;
                &lt;xs:attribute name=&quot;recoveryInfoCacheName&quot; type=&quot;xs:string&quot;&gt;
                  &lt;xs:annotation&gt;
                    &lt;xs:documentation&gt;
                      Sets the name of the cache where recovery related information is held. The cache's default name is specified by Configuration.RecoveryType.DEFAULT_RECOVERY_INFO_CACHE.
                    &lt;/xs:documentation&gt;
                  &lt;/xs:annotation&gt;
                &lt;/xs:attribute&gt;
              &lt;/xs:complexType&gt;
            &lt;/xs:element&gt;
          &lt;/xs:sequence&gt;
          &lt;xs:attribute name=&quot;cacheStopTimeout&quot; type=&quot;xs:int&quot;&gt;
            &lt;xs:annotation&gt;
              &lt;xs:documentation&gt;
                If there are any ongoing transactions when a cache is stopped, Infinispan waits for ongoing remote and local transactions to finish. The amount of time to wait for is defined by the cache stop timeout. It is recommended that this value does not exceed the transaction timeout because even if a new transaction was started just before the cache was stopped, this could only last as long as the transaction timeout allows it.
              &lt;/xs:documentation&gt;
            &lt;/xs:annotation&gt;
          &lt;/xs:attribute&gt;
          &lt;xs:attribute name=&quot;completedTxTimeout&quot; type=&quot;xs:long&quot;&gt;
            &lt;xs:annotation&gt;
              &lt;xs:documentation&gt;
                The duration (millis) in which to keep information about the completion of a transaction. Defaults to 15000.
              &lt;/xs:documentation&gt;
            &lt;/xs:annotation&gt;
          &lt;/xs:attribute&gt;
          &lt;xs:attribute name=&quot;reaperWakeUpInterval&quot; type=&quot;xs:long&quot;&gt;
            &lt;xs:annotation&gt;
              &lt;xs:documentation&gt;
                The time interval (millis) at which the thread that cleans up transaction completion information kicks in. Defaults to 1000.
              &lt;/xs:documentation&gt;
            &lt;/xs:annotation&gt;
          &lt;/xs:attribute&gt;
          &lt;xs:attribute name=&quot;eagerLockSingleNode&quot; type=&quot;xs:boolean&quot;&gt;
            &lt;xs:annotation&gt;
              &lt;xs:documentation&gt;
                 Only has effect for DIST mode and when useEagerLocking is set to true. When this is enabled, then only one node is locked in the cluster, disregarding numOwners config. On the opposite, if this is false, then on all cache.lock() calls numOwners RPCs are being performed. The node that gets locked is the main data owner, i.e. the node where data would reside if numOwners==1. If the node where the lock resides crashes, then the transaction is marked for rollback - data is in a consistent state, no fault tolerance. Starting with Infinispan 5.1 single node locking is used by default.
              &lt;/xs:documentation&gt;
            &lt;/xs:annotation&gt;
          &lt;/xs:attribute&gt;
          &lt;xs:attribute name=&quot;syncCommitPhase&quot; type=&quot;xs:boolean&quot;&gt;
            &lt;xs:annotation&gt;
              &lt;xs:documentation&gt;
                If true, the cluster-wide commit phase in two-phase commit (2PC) transactions will be synchronous, so Infinispan will wait for responses from all nodes to which the commit was sent. Otherwise, the commit phase will be asynchronous. Keeping it as false improves performance of 2PC transactions, since any remote failures are trapped during the prepare phase anyway and appropriate rollbacks are issued.
              &lt;/xs:documentation&gt;
            &lt;/xs:annotation&gt;
          &lt;/xs:attribute&gt;
          &lt;xs:attribute name=&quot;syncRollbackPhase&quot; type=&quot;xs:boolean&quot;&gt;
            &lt;xs:annotation&gt;
              &lt;xs:documentation&gt;
                If true, the cluster-wide rollback phase in two-phase commit (2PC) transactions will be synchronous, so Infinispan will wait for responses from all nodes to which the rollback was sent. Otherwise, the rollback phase will be asynchronous. Keeping it as false improves performance of 2PC transactions.
              &lt;/xs:documentation&gt;
            &lt;/xs:annotation&gt;
          &lt;/xs:attribute&gt;
          &lt;xs:attribute name=&quot;transactionManagerLookupClass&quot; type=&quot;xs:string&quot;&gt;
            &lt;xs:annotation&gt;
              &lt;xs:documentation&gt;
                Configure Transaction manager lookup directly using an instance of TransactionManagerLookup. Calling this method marks the cache as transactional.
              &lt;/xs:documentation&gt;
            &lt;/xs:annotation&gt;
          &lt;/xs:attribute&gt;
          &lt;xs:attribute name=&quot;useEagerLocking&quot; type=&quot;xs:boolean&quot;&gt;
            &lt;xs:annotation&gt;
              &lt;xs:documentation&gt;
                 Only has effect for DIST mode and when useEagerLocking is set to true. When this is enabled, then only one node is locked in the cluster, disregarding numOwners config. On the opposite, if this is false, then on all cache.lock() calls numOwners RPCs are being performed. The node that gets locked is the main data owner, i.e. the node where data would reside if numOwners==1. If the node where the lock resides crashes, then the transaction is marked for rollback - data is in a consistent state, no fault tolerance. Note: Starting with infinispan 5.1 eager locking is replaced with pessimistic locking and can be enforced by setting transaction's locking mode to PESSIMISTIC.
              &lt;/xs:documentation&gt;
            &lt;/xs:annotation&gt;
          &lt;/xs:attribute&gt;
          &lt;xs:attribute name=&quot;useSynchronization&quot; type=&quot;xs:boolean&quot;&gt;
           &lt;xs:annotation&gt;
              &lt;xs:documentation&gt;
                 Configures whether the cache registers a synchronization with the transaction manager, or registers itself as an XA resource. It is often unnecessary to register as a full XA resource unless you intend to make use of recovery as well, and registering a synchronization is significantly more efficient.
              &lt;/xs:documentation&gt;
           &lt;/xs:annotation&gt;
          &lt;/xs:attribute&gt;
          &lt;xs:attribute name=&quot;lockingMode&quot; type=&quot;tns:lockingMode&quot;&gt;
            &lt;xs:annotation&gt;
              &lt;xs:documentation&gt;
                Configures whether the cache uses optimistic or pessimistic locking. If the cache is not transactional then the locking mode is ignored. See transactioMode.
              &lt;/xs:documentation&gt;
            &lt;/xs:annotation&gt;
          &lt;/xs:attribute&gt;
          &lt;xs:attribute name=&quot;transactionMode&quot; type=&quot;tns:transactionMode&quot;&gt;
            &lt;xs:annotation&gt;
              &lt;xs:documentation&gt;
                Configures whether the cache is transactional or not.
              &lt;/xs:documentation&gt;
            &lt;/xs:annotation&gt;
          &lt;/xs:attribute&gt;
          &lt;xs:attribute name=&quot;autoCommit&quot; type=&quot;xs:boolean&quot;&gt;
            &lt;xs:annotation&gt;
              &lt;xs:documentation&gt;
                If the cache is transactional and transactionAutoCommit is enabled then for single operation transactions the user doesn't need to manually start a transaction, but a transactions is injected by the system. Defaults to true.
              &lt;/xs:documentation&gt;
            &lt;/xs:annotation&gt;
          &lt;/xs:attribute&gt;
          &lt;xs:attribute name=&quot;use1PcForAutoCommitTransactions&quot; type=&quot;xs:boolean&quot;&gt;
            &lt;xs:annotation&gt;
              &lt;xs:documentation&gt;
                Before Infinispan 5.1 you could access the cache both transactionally and non-transactionally. Naturally the non-transactional access is faster and offers less consistency guarantees. From Infinispan 5.1 onwards, mixed access is no longer supported, so if you wanna speed up transactional caches and you're ready to trade some consistency guarantees, you can enable use1PcForAutoCommitTransactions. What this configuration option does is force an induced transaction, that has been started by Infinispan as a result of enabling autoCommit, to commit in a single phase. So only 1 RPC instead of 2RPCs as in the case of a full 2 Phase Commit (2PC).
              &lt;/xs:documentation&gt;
            &lt;/xs:annotation&gt;
          &lt;/xs:attribute&gt;
        &lt;/xs:complexType&gt;
      &lt;/xs:element&gt;
      &lt;xs:element name=&quot;customInterceptors&quot; minOccurs=&quot;0&quot;&gt;
        &lt;xs:annotation&gt;
          &lt;xs:documentation&gt;
            Configures custom interceptors to be added to the cache.
          &lt;/xs:documentation&gt;
        &lt;/xs:annotation&gt;
        &lt;xs:complexType&gt;
          &lt;xs:sequence&gt;
            &lt;xs:element name=&quot;interceptor&quot; minOccurs=&quot;0&quot; maxOccurs=&quot;unbounded&quot;&gt;
              &lt;xs:complexType&gt;
                &lt;xs:sequence&gt;
                  &lt;xs:element name=&quot;properties&quot; type=&quot;tns:properties&quot; minOccurs=&quot;0&quot;/&gt;
                &lt;/xs:sequence&gt;
                &lt;xs:attribute name=&quot;after&quot; type=&quot;xs:string&quot;&gt;
                   &lt;xs:annotation&gt;&lt;xs:documentation&gt;Dictates that the custom interceptor appears immediately after the specified interceptor. If the specified interceptor is not found in the interceptor chain, a ConfigurationException will be thrown when the cache starts.&lt;/xs:documentation&gt;&lt;/xs:annotation&gt;
                &lt;/xs:attribute&gt;
                &lt;xs:attribute name=&quot;before&quot; type=&quot;xs:string&quot;&gt;
                   &lt;xs:annotation&gt;&lt;xs:documentation&gt;Dictates that the custom interceptor appears immediately before the specified interceptor. If the specified interceptor is not found in the interceptor chain, a ConfigurationException will be thrown when the cache starts.&lt;/xs:documentation&gt;&lt;/xs:annotation&gt;
                &lt;/xs:attribute&gt;
                &lt;xs:attribute name=&quot;class&quot; type=&quot;xs:string&quot;&gt;
                   &lt;xs:annotation&gt;&lt;xs:documentation&gt;A fully qualified class name of the new custom interceptor to add to the configuration.&lt;/xs:documentation&gt;&lt;/xs:annotation&gt;
                &lt;/xs:attribute&gt;
                &lt;xs:attribute name=&quot;index&quot; type=&quot;xs:int&quot;&gt;
                   &lt;xs:annotation&gt;&lt;xs:documentation&gt;Specifies a position in the interceptor chain to place the new interceptor. The index starts at 0 and goes up to the number of interceptors in a given configuration. A ConfigurationException is thrown if the index is less than 0 or greater than the maximum number of interceptors in the chain.&lt;/xs:documentation&gt;&lt;/xs:annotation&gt;
                &lt;/xs:attribute&gt;
                &lt;xs:attribute name=&quot;position&quot; type=&quot;xs:string&quot;&gt;
                   &lt;xs:annotation&gt;&lt;xs:documentation&gt;Specifies a position where to place the new interceptor. Allowed values are FIRST, LAST, and OTHER_THAN_FIRST_OR_LAST&lt;/xs:documentation&gt;&lt;/xs:annotation&gt;
                &lt;/xs:attribute&gt;
              &lt;/xs:complexType&gt;
            &lt;/xs:element&gt;
          &lt;/xs:sequence&gt;
        &lt;/xs:complexType&gt;
      &lt;/xs:element&gt;
      &lt;xs:element name=&quot;dataContainer&quot; minOccurs=&quot;0&quot;&gt;
        &lt;xs:annotation&gt;
          &lt;xs:documentation&gt;
            Controls the data container for the cache.
          &lt;/xs:documentation&gt;
        &lt;/xs:annotation&gt;
        &lt;xs:complexType&gt;
          &lt;xs:sequence&gt;
            &lt;xs:element name=&quot;properties&quot; type=&quot;tns:properties&quot; minOccurs=&quot;0&quot;&gt;
              &lt;xs:annotation&gt;
                &lt;xs:documentation&gt;Properties passed to the data container&lt;/xs:documentation&gt;
              &lt;/xs:annotation&gt;
            &lt;/xs:element&gt;
          &lt;/xs:sequence&gt;
          &lt;xs:attribute name=&quot;class&quot; type=&quot;xs:string&quot;&gt;
            &lt;xs:annotation&gt;
              &lt;xs:documentation&gt;
                Fully qualified class name of the data container to use
              &lt;/xs:documentation&gt;
            &lt;/xs:annotation&gt;
          &lt;/xs:attribute&gt;
        &lt;/xs:complexType&gt;
      &lt;/xs:element&gt;
      &lt;xs:element name=&quot;eviction&quot; minOccurs=&quot;0&quot;&gt;
        &lt;xs:annotation&gt;
          &lt;xs:documentation&gt;
            Controls the eviction settings for the cache.
          &lt;/xs:documentation&gt;
        &lt;/xs:annotation&gt;
        &lt;xs:complexType&gt;
          &lt;xs:attribute name=&quot;maxEntries&quot; type=&quot;xs:int&quot;&gt;
            &lt;xs:annotation&gt;
              &lt;xs:documentation&gt;
                Maximum number of entries in a cache instance. Cache size is guaranteed not to exceed upper limit specified by max entries. However, due to the nature of eviction it is unlikely to ever be exactly maximum number of entries specified here.
              &lt;/xs:documentation&gt;
            &lt;/xs:annotation&gt;
          &lt;/xs:attribute&gt;
          &lt;xs:attribute name=&quot;strategy&quot; type=&quot;tns:evictionStrategy&quot;&gt;
            &lt;xs:annotation&gt;
              &lt;xs:documentation&gt;
                Eviction strategy. Available options are 'UNORDERED', 'LRU', 'LIRS' and 'NONE' (to disable eviction).
              &lt;/xs:documentation&gt;
            &lt;/xs:annotation&gt;
          &lt;/xs:attribute&gt;
          &lt;xs:attribute name=&quot;threadPolicy&quot; type=&quot;tns:evictionThreadPolicy&quot;&gt;
            &lt;xs:annotation&gt;
              &lt;xs:documentation&gt;
                Threading policy for eviction.
              &lt;/xs:documentation&gt;
            &lt;/xs:annotation&gt;
          &lt;/xs:attribute&gt;
        &lt;/xs:complexType&gt;
      &lt;/xs:element&gt;
      &lt;xs:element name=&quot;expiration&quot; minOccurs=&quot;0&quot;&gt;
        &lt;xs:annotation&gt;
          &lt;xs:documentation&gt;
            Controls the default expiration settings for entries in the cache.
          &lt;/xs:documentation&gt;
        &lt;/xs:annotation&gt;
        &lt;xs:complexType&gt;
           &lt;xs:attribute name=&quot;wakeUpInterval&quot; type=&quot;xs:long&quot;&gt;
            &lt;xs:annotation&gt;
              &lt;xs:documentation&gt;
                Interval (in milliseconds) between subsequent runs to purge expired entries from memory and any cache stores. If you wish to disable the periodic eviction process altogether, set wakeupInterval to -1.
              &lt;/xs:documentation&gt;
            &lt;/xs:annotation&gt;
           &lt;/xs:attribute&gt;
           &lt;xs:attribute name=&quot;lifespan&quot; type=&quot;xs:long&quot;&gt;
            &lt;xs:annotation&gt;
              &lt;xs:documentation&gt;
                Maximum lifespan of a cache entry, after which the entry is expired cluster-wide, in milliseconds. -1 means the entries never expire. Note that this can be overridden on a per-entry basis by using the Cache API.
              &lt;/xs:documentation&gt;
            &lt;/xs:annotation&gt;
           &lt;/xs:attribute&gt;
           &lt;xs:attribute name=&quot;maxIdle&quot; type=&quot;xs:long&quot;&gt;
            &lt;xs:annotation&gt;
              &lt;xs:documentation&gt;
                Maximum idle time a cache entry will be maintained in the cache, in milliseconds. If the idle time is exceeded, the entry will be expired cluster-wide. -1 means the entries never expire. Note that this can be overridden on a per-entry basis by using the Cache API.
              &lt;/xs:documentation&gt;
            &lt;/xs:annotation&gt;
           &lt;/xs:attribute&gt;
           &lt;xs:attribute name=&quot;reaperEnabled&quot; type=&quot;xs:boolean&quot;&gt;
            &lt;xs:annotation&gt;
              &lt;xs:documentation&gt;
                Determines whether the background reaper thread is enabled to test entries for expiration. Regardless of whether a reaper is used, entries are tested for expiration lazily when they are touched.
              &lt;/xs:documentation&gt;
            &lt;/xs:annotation&gt;
           &lt;/xs:attribute&gt;
        &lt;/xs:complexType&gt;
      &lt;/xs:element&gt;
      &lt;xs:element name=&quot;unsafe&quot; minOccurs=&quot;0&quot;&gt;
        &lt;xs:annotation&gt;
          &lt;xs:documentation&gt;
            Controls certain tuning parameters that may break some of Infinispan's public API contracts in exchange for better performance in some cases. Use with care, only after thoroughly reading and understanding the documentation about a specific feature.
          &lt;/xs:documentation&gt;
        &lt;/xs:annotation&gt;
        &lt;xs:complexType&gt;
           &lt;xs:attribute name=&quot;unreliableReturnValues&quot; type=&quot;xs:boolean&quot;&gt;
            &lt;xs:annotation&gt;
              &lt;xs:documentation&gt;
                Specifies whether Infinispan is allowed to disregard the Map contract when providing return values for org.infinispan.Cache#put(Object, Object) and org.infinispan.Cache#remove(Object) methods.
              &lt;/xs:documentation&gt;
            &lt;/xs:annotation&gt;
           &lt;/xs:attribute&gt;
        &lt;/xs:complexType&gt;
      &lt;/xs:element&gt;
      &lt;xs:element name=&quot;versioning&quot; minOccurs=&quot;0&quot;&gt;
        &lt;xs:annotation&gt;
          &lt;xs:documentation&gt;
            Controls whether entries are versioned.  Versioning is necessary, for example, when using optimistic transactions in a clustered environment, to be able to perform write-skew checks.
          &lt;/xs:documentation&gt;
        &lt;/xs:annotation&gt;
        &lt;xs:complexType&gt;
          &lt;xs:attribute name=&quot;enabled&quot; type=&quot;xs:boolean&quot; default=&quot;false&quot;&gt;
            &lt;xs:annotation&gt;
              &lt;xs:documentation&gt;
                Determines whether versioning is enabled or disabled for this cache. Defaults to disabled
              &lt;/xs:documentation&gt;
            &lt;/xs:annotation&gt;
           &lt;/xs:attribute&gt;
           &lt;xs:attribute name=&quot;versioningScheme&quot; type=&quot;tns:versioningScheme&quot;&gt;
            &lt;xs:annotation&gt;
              &lt;xs:documentation&gt;
                The scheme to use when versioning entries. Can be either SIMPLE or NONE. Defaults to NONE
              &lt;/xs:documentation&gt;
            &lt;/xs:annotation&gt;
           &lt;/xs:attribute&gt;
        &lt;/xs:complexType&gt;
      &lt;/xs:element&gt;
      &lt;xs:element name=&quot;clustering&quot; minOccurs=&quot;0&quot;&gt;
        &lt;xs:annotation&gt;
          &lt;xs:documentation&gt;
            Defines clustered characteristics of the cache.
          &lt;/xs:documentation&gt;
        &lt;/xs:annotation&gt;
        &lt;xs:complexType&gt;
          &lt;xs:all&gt;
            &lt;xs:element name=&quot;sync&quot; minOccurs=&quot;0&quot;&gt;
              &lt;xs:annotation&gt;
                &lt;xs:documentation&gt;
                  If configured all communications are synchronous, in that whenever a thread sends a message sent over the wire, it blocks until it receives an acknowledgment from the recipient. Sync configuration is mutually exclusive with async configuration. 
                &lt;/xs:documentation&gt;
              &lt;/xs:annotation&gt;
              &lt;xs:complexType&gt;
                &lt;xs:attribute name=&quot;replTimeout&quot; type=&quot;xs:long&quot;&gt;
                  &lt;xs:annotation&gt;
                    &lt;xs:documentation&gt;
                      This is the timeout used to wait for an acknowledgment when making a remote call, after which the call is aborted and an exception is thrown.
                    &lt;/xs:documentation&gt;
                  &lt;/xs:annotation&gt;
                &lt;/xs:attribute&gt;
              &lt;/xs:complexType&gt;
            &lt;/xs:element&gt;
            &lt;xs:element name=&quot;stateTransfer&quot; minOccurs=&quot;0&quot;&gt;
              &lt;xs:annotation&gt;
                &lt;xs:documentation&gt;
                  Configures how state is transferred when a cache joins or leaves the cluster. Used in distributed and replication clustered modes.
                &lt;/xs:documentation&gt;
              &lt;/xs:annotation&gt;
              &lt;xs:complexType&gt;
                &lt;xs:attribute name=&quot;chunkSize&quot; type=&quot;xs:int&quot;&gt;
                  &lt;xs:annotation&gt;
                    &lt;xs:documentation&gt;
                       If &amp;gt; 0, the state will be transferred in batches of {@code chunkSize} cache entries. If &amp;lt;= 0, the state will be transferred in all at once. Not recommended.
                    &lt;/xs:documentation&gt;
                  &lt;/xs:annotation&gt;
                &lt;/xs:attribute&gt;
                &lt;xs:attribute name=&quot;fetchInMemoryState&quot; type=&quot;xs:boolean&quot;&gt;
                  &lt;xs:annotation&gt;
                    &lt;xs:documentation&gt;
                      If true, this will cause the cache to ask neighboring caches for state when it starts up, so the cache starts 'warm', although it will impact startup time.
                    &lt;/xs:documentation&gt;
                  &lt;/xs:annotation&gt;
                &lt;/xs:attribute&gt;
                &lt;xs:attribute name=&quot;awaitInitialTransfer&quot; type=&quot;xs:boolean&quot;&gt;
                  &lt;xs:annotation&gt;
                    &lt;xs:documentation&gt;
                       If true, this will cause the first call to method CacheManager.getCache() on the joiner node to block and wait until the joining is complete and the cache has finished
                       receiving state from neighboring caches (if fetchInMemoryState is enabled). This option applies to distributed and replicated caches only and is enabled by default.
                       Please note that setting this to false will make the cache object available immediately but any access to keys that should be available locally but are not yet transferred
                       will actually cause a (transparent) remote access. While this will not have any impact on the logic of your application it might impact performance.
                    &lt;/xs:documentation&gt;
                  &lt;/xs:annotation&gt;
                &lt;/xs:attribute&gt;
                &lt;xs:attribute name=&quot;timeout&quot; type=&quot;xs:long&quot;&gt;
                  &lt;xs:annotation&gt;
                    &lt;xs:documentation&gt;
                      This is the maximum amount of time - in milliseconds - to wait for state from neighboring caches, before throwing an exception and aborting startup.
                    &lt;/xs:documentation&gt;
                  &lt;/xs:annotation&gt;
                &lt;/xs:attribute&gt;
              &lt;/xs:complexType&gt;
            &lt;/xs:element&gt;
            &lt;xs:element name=&quot;l1&quot; minOccurs=&quot;0&quot;&gt;
              &lt;xs:annotation&gt;
                &lt;xs:documentation&gt;
                  Configures the L1 cache behavior in 'distributed' caches instances. In any other cache modes, this element is ignored.
                &lt;/xs:documentation&gt;
              &lt;/xs:annotation&gt;
              &lt;xs:complexType&gt;
                &lt;xs:attribute name=&quot;enabled&quot; type=&quot;xs:boolean&quot;&gt;
                  &lt;xs:annotation&gt;
                    &lt;xs:documentation&gt;
                      Enable the L1 cache.
                    &lt;/xs:documentation&gt;
                  &lt;/xs:annotation&gt;
                &lt;/xs:attribute&gt;
                &lt;xs:attribute name=&quot;invalidationThreshold&quot; type=&quot;xs:int&quot;&gt;
                  &lt;xs:annotation&gt;
                    &lt;xs:documentation&gt;
                      Determines whether a multicast or a web of unicasts are used when performing L1 invalidations. By default multicast will be used. If the threshold is set to -1, then unicasts will always be used. If the threshold is set to  0, then multicast will be always be used.
                    &lt;/xs:documentation&gt;
                  &lt;/xs:annotation&gt;
                &lt;/xs:attribute&gt;
                &lt;xs:attribute name=&quot;lifespan&quot; type=&quot;xs:long&quot;&gt;
                  &lt;xs:annotation&gt;
                    &lt;xs:documentation&gt;
                      Maximum lifespan of an entry placed in the L1 cache.
                    &lt;/xs:documentation&gt;
                  &lt;/xs:annotation&gt;
                &lt;/xs:attribute&gt;
                &lt;xs:attribute name=&quot;cleanupTaskFrequency&quot; type=&quot;xs:long&quot;&gt;
                   &lt;xs:annotation&gt;
                      &lt;xs:documentation&gt;
                         Controls how often a cleanup task to prune L1 tracking data is run.
                      &lt;/xs:documentation&gt;
                   &lt;/xs:annotation&gt;
                &lt;/xs:attribute&gt;
                &lt;xs:attribute name=&quot;onRehash&quot; type=&quot;xs:boolean&quot;&gt;
                  &lt;xs:annotation&gt;
                    &lt;xs:documentation&gt;
                       If enabled, entries removed due to a rehash will be moved to L1 rather than being removed altogether.
                    &lt;/xs:documentation&gt;
                  &lt;/xs:annotation&gt;
                &lt;/xs:attribute&gt;
              &lt;/xs:complexType&gt;
            &lt;/xs:element&gt;
            &lt;xs:element name=&quot;async&quot; minOccurs=&quot;0&quot;&gt;
              &lt;xs:annotation&gt;
                &lt;xs:documentation&gt;
                  If configured all communications are asynchronous, in that whenever a thread sends a message sent over the wire, it does not wait for an acknowledgment before returning. Asynchronous configuration is mutually exclusive with synchronous configuration.
                &lt;/xs:documentation&gt;
              &lt;/xs:annotation&gt;
              &lt;xs:complexType&gt;
                &lt;xs:annotation&gt;
                  &lt;xs:documentation&gt;
                    If configured all communications are asynchronous, in that whenever a thread sends a message sent over the wire, it does not wait for an acknowledgment before returning. &amp;lt;async&amp;gt; is mutually exclusive with the &amp;lt;sync&amp;gt;.
                  &lt;/xs:documentation&gt;
                &lt;/xs:annotation&gt;
                &lt;xs:attribute name=&quot;asyncMarshalling&quot; type=&quot;xs:boolean&quot;&gt;
                  &lt;xs:annotation&gt;
                    &lt;xs:documentation&gt;
                      If true, asynchronous marshalling is enabled which means that caller can return even quicker, but it can suffer from reordering of operations. You can find more information at https://docs.jboss.org/author/display/ISPN/Asynchronous+Options
                    &lt;/xs:documentation&gt;
                  &lt;/xs:annotation&gt;
                &lt;/xs:attribute&gt;
                &lt;xs:attribute name=&quot;replQueueClass&quot; type=&quot;xs:string&quot;&gt;
                  &lt;xs:annotation&gt;
                    &lt;xs:documentation&gt;
                      The replication queue in use, by default ReplicationQueueImpl.
                    &lt;/xs:documentation&gt;
                  &lt;/xs:annotation&gt;
                &lt;/xs:attribute&gt;
                &lt;xs:attribute name=&quot;replQueueInterval&quot; type=&quot;xs:long&quot;&gt;
                  &lt;xs:annotation&gt;
                    &lt;xs:documentation&gt;
                      If useReplQueue is set to true, this attribute controls how often the asynchronous thread used to flush the replication queue runs.
                    &lt;/xs:documentation&gt;
                  &lt;/xs:annotation&gt;
                &lt;/xs:attribute&gt;
                &lt;xs:attribute name=&quot;replQueueMaxElements&quot; type=&quot;xs:int&quot;&gt;
                  &lt;xs:annotation&gt;
                    &lt;xs:documentation&gt;
                      If useReplQueue is set to true, this attribute can be used to trigger flushing of the queue when it reaches a specific threshold.
                    &lt;/xs:documentation&gt;
                  &lt;/xs:annotation&gt;
                &lt;/xs:attribute&gt;
                &lt;xs:attribute name=&quot;useReplQueue&quot; type=&quot;xs:boolean&quot;&gt;
                  &lt;xs:annotation&gt;
                    &lt;xs:documentation&gt;
                      If true, forces all async communications to be queued up and sent out periodically as a batch.
                    &lt;/xs:documentation&gt;
                  &lt;/xs:annotation&gt;
                &lt;/xs:attribute&gt;
              &lt;/xs:complexType&gt;
            &lt;/xs:element&gt;
            &lt;xs:element name=&quot;hash&quot; minOccurs=&quot;0&quot;&gt;
              &lt;xs:annotation&gt;
                &lt;xs:documentation&gt;
                  Allows fine-tuning of rehashing characteristics. Must only used with 'distributed' cache mode.
                &lt;/xs:documentation&gt;
              &lt;/xs:annotation&gt;
              &lt;xs:complexType&gt;
                &lt;xs:sequence&gt;
                  &lt;xs:element name=&quot;groups&quot; minOccurs=&quot;0&quot;&gt;
                    &lt;xs:complexType&gt;
                      &lt;xs:sequence&gt;
                        &lt;xs:element name=&quot;grouper&quot; minOccurs=&quot;0&quot; maxOccurs=&quot;unbounded&quot;&gt;
                          &lt;xs:complexType&gt;
                            &lt;xs:attribute name=&quot;class&quot; type=&quot;xs:string&quot;/&gt;
                          &lt;/xs:complexType&gt;
                        &lt;/xs:element&gt;
                      &lt;/xs:sequence&gt;
                      &lt;xs:attribute name=&quot;enabled&quot; type=&quot;xs:boolean&quot;/&gt;
                    &lt;/xs:complexType&gt;
                  &lt;/xs:element&gt;
                &lt;/xs:sequence&gt;
                &lt;xs:attribute name=&quot;factory&quot; type=&quot;xs:string&quot;&gt;
                  &lt;xs:annotation&gt;
                    &lt;xs:documentation&gt;
                       The factory to use for generating the consistent hash. Must implement org.infinispan.distribution.ch.ConsistentHashFactory.
                    &lt;/xs:documentation&gt;
                  &lt;/xs:annotation&gt;
                &lt;/xs:attribute&gt;
                &lt;xs:attribute name=&quot;hashFunctionClass&quot; type=&quot;xs:string&quot;&gt;
                  &lt;xs:annotation&gt;
                    &lt;xs:documentation&gt;
                      The hash function used as a bit spreader and a general hash code generator. Must implement org.infinispan.commons.hash.Hash.
                    &lt;/xs:documentation&gt;
                  &lt;/xs:annotation&gt;
                &lt;/xs:attribute&gt;
                &lt;xs:attribute name=&quot;numOwners&quot; type=&quot;xs:int&quot;&gt;
                  &lt;xs:annotation&gt;
                    &lt;xs:documentation&gt;
                      Number of cluster-wide replicas for each cache entry.
                    &lt;/xs:documentation&gt;
                  &lt;/xs:annotation&gt;
                &lt;/xs:attribute&gt;
                &lt;xs:attribute name=&quot;numSegments&quot; type=&quot;xs:int&quot;&gt;
                  &lt;xs:annotation&gt;
                    &lt;xs:documentation&gt;
                      Controls the total number of hash space segments (per cluster). Recommended value is 10 * max_cluster_size.
                    &lt;/xs:documentation&gt;
                  &lt;/xs:annotation&gt;
                &lt;/xs:attribute&gt;
              &lt;/xs:complexType&gt;
            &lt;/xs:element&gt;
          &lt;/xs:all&gt;
          &lt;xs:attribute name=&quot;mode&quot; type=&quot;xs:string&quot;&gt;
            &lt;xs:annotation&gt;
              &lt;xs:documentation&gt;
                Cache mode. For distribution, set mode to either 'dist'. For replication, use 'repl'. Finally, for invalidation 'inv'. If the cache mode is set to 'local', the cache in question will not support clustering even if its cache manager does.
              &lt;/xs:documentation&gt;
            &lt;/xs:annotation&gt;
          &lt;/xs:attribute&gt;
        &lt;/xs:complexType&gt;
      &lt;/xs:element&gt;
      &lt;xs:element name=&quot;jmxStatistics&quot; minOccurs=&quot;0&quot;&gt;
        &lt;xs:annotation&gt;
          &lt;xs:documentation&gt;
            Determines whether statistics are gather and reported.
          &lt;/xs:documentation&gt;
        &lt;/xs:annotation&gt;
        &lt;xs:complexType&gt;
          &lt;xs:attribute name=&quot;enabled&quot; type=&quot;xs:boolean&quot;&gt;
            &lt;xs:annotation&gt;
              &lt;xs:documentation&gt;
                Enable or disable statistics gathering and reporting
              &lt;/xs:documentation&gt;
            &lt;/xs:annotation&gt;
          &lt;/xs:attribute&gt;
        &lt;/xs:complexType&gt;
      &lt;/xs:element&gt;
      &lt;xs:element name=&quot;storeAsBinary&quot; minOccurs=&quot;0&quot;&gt;
        &lt;xs:annotation&gt;
          &lt;xs:documentation&gt;
            Controls whether when stored in memory, keys and values are stored as references to their original objects, or in a serialized, binary format.  There are benefits to both approaches, but often if used in a clustered mode, storing objects as binary means that the cost of serialization happens early on, and can be amortized.  Further, deserialization costs are incurred lazily which improves throughput. It is possible to control this on a fine-grained basis: you can choose to just store keys or values as binary, or both.
          &lt;/xs:documentation&gt;
        &lt;/xs:annotation&gt;
        &lt;xs:complexType&gt;
          &lt;xs:attribute name=&quot;enabled&quot; type=&quot;xs:boolean&quot;&gt;
            &lt;xs:annotation&gt;
              &lt;xs:documentation&gt;
                Enables storing both keys and values as binary.
              &lt;/xs:documentation&gt;
            &lt;/xs:annotation&gt;
          &lt;/xs:attribute&gt;
          &lt;xs:attribute name=&quot;storeKeysAsBinary&quot; type=&quot;xs:boolean&quot;&gt;
            &lt;xs:annotation&gt;
              &lt;xs:documentation&gt;
                Specify whether keys are stored as binary or not.
              &lt;/xs:documentation&gt;
            &lt;/xs:annotation&gt;
          &lt;/xs:attribute&gt;
          &lt;xs:attribute name=&quot;storeValuesAsBinary&quot; type=&quot;xs:boolean&quot;&gt;
            &lt;xs:annotation&gt;
              &lt;xs:documentation&gt;
                Specify whether values are stored as binary or not.
              &lt;/xs:documentation&gt;
            &lt;/xs:annotation&gt;
          &lt;/xs:attribute&gt;
        &lt;/xs:complexType&gt;
      &lt;/xs:element&gt;
      &lt;xs:element name=&quot;lazyDeserialization&quot; minOccurs=&quot;0&quot;&gt;
        &lt;xs:annotation&gt;
          &lt;xs:documentation&gt;
            Deprecated configuration element. Use storeAsBinary instead.
          &lt;/xs:documentation&gt;
        &lt;/xs:annotation&gt;
        &lt;xs:complexType&gt;
          &lt;xs:attribute name=&quot;enabled&quot; type=&quot;xs:boolean&quot;/&gt;
        &lt;/xs:complexType&gt;
      &lt;/xs:element&gt;
      &lt;xs:element name=&quot;invocationBatching&quot; minOccurs=&quot;0&quot;&gt;
        &lt;xs:complexType&gt;
          &lt;xs:attribute name=&quot;enabled&quot; type=&quot;xs:boolean&quot;/&gt;
        &lt;/xs:complexType&gt;
      &lt;/xs:element&gt;
      &lt;xs:element name=&quot;deadlockDetection&quot; minOccurs=&quot;0&quot;&gt;
        &lt;xs:annotation&gt;
          &lt;xs:documentation&gt;
            Configures deadlock detection.
          &lt;/xs:documentation&gt;
        &lt;/xs:annotation&gt;
        &lt;xs:complexType&gt;
          &lt;xs:attribute name=&quot;enabled&quot; type=&quot;xs:boolean&quot;&gt;
            &lt;xs:annotation&gt;
              &lt;xs:documentation&gt;
                Enable or disable deadlock detection
              &lt;/xs:documentation&gt;
            &lt;/xs:annotation&gt;
          &lt;/xs:attribute&gt;
          &lt;xs:attribute name=&quot;spinDuration&quot; type=&quot;xs:long&quot;&gt;
            &lt;xs:annotation&gt;
              &lt;xs:documentation&gt;
                Time period that determines how often is lock acquisition attempted within maximum time allowed to acquire a particular lock
              &lt;/xs:documentation&gt;
            &lt;/xs:annotation&gt;
          &lt;/xs:attribute&gt;
        &lt;/xs:complexType&gt;
      &lt;/xs:element&gt;
      &lt;xs:element name=&quot;indexing&quot; minOccurs=&quot;0&quot;&gt;
        &lt;xs:annotation&gt;
          &lt;xs:documentation&gt;
            Configures indexing of entries in the cache for searching.
          &lt;/xs:documentation&gt;
        &lt;/xs:annotation&gt;
        &lt;xs:complexType&gt;
          &lt;xs:sequence&gt;
            &lt;xs:element name=&quot;properties&quot; type=&quot;tns:properties&quot; minOccurs=&quot;0&quot;&gt;
              &lt;xs:annotation&gt;
                &lt;xs:documentation&gt;
                  The Query engine relies on properties for configuration. These properties are passed directly to the embedded Hibernate Search engine, so for the complete and up to date documentation about available properties refer to the Hibernate Search reference of the version you're using with Infinispan Query.
                &lt;/xs:documentation&gt;
              &lt;/xs:annotation&gt;
            &lt;/xs:element&gt;
          &lt;/xs:sequence&gt;
          &lt;xs:attribute name=&quot;enabled&quot; type=&quot;xs:boolean&quot;&gt;
            &lt;xs:annotation&gt;
              &lt;xs:documentation&gt;
                Enable or disable indexing
              &lt;/xs:documentation&gt;
            &lt;/xs:annotation&gt;
          &lt;/xs:attribute&gt;
          &lt;xs:attribute name=&quot;indexLocalOnly&quot; type=&quot;xs:boolean&quot;&gt;
            &lt;xs:annotation&gt;
              &lt;xs:documentation&gt;
                If true, only index changes made locally, ignoring remote changes. This is useful if indexes are shared across a cluster to prevent redundant indexing of updates.
              &lt;/xs:documentation&gt;
            &lt;/xs:annotation&gt;
          &lt;/xs:attribute&gt;
        &lt;/xs:complexType&gt;
      &lt;/xs:element&gt;
      &lt;xs:element name=&quot;modules&quot; minOccurs=&quot;0&quot;&gt;
        &lt;xs:annotation&gt;
          &lt;xs:documentation&gt;
            This element contains configuration options for additional modules which affect cache configuration
          &lt;/xs:documentation&gt;
        &lt;/xs:annotation&gt;
        &lt;xs:complexType&gt;
          &lt;xs:sequence minOccurs=&quot;0&quot; maxOccurs=&quot;unbounded&quot;&gt;
            &lt;xs:any namespace=&quot;##other&quot;/&gt;
          &lt;/xs:sequence&gt;
        &lt;/xs:complexType&gt;
      &lt;/xs:element&gt;
    &lt;/xs:all&gt;
    &lt;xs:attribute name=&quot;name&quot; type=&quot;xs:string&quot;/&gt;
  &lt;/xs:complexType&gt;

  &lt;xs:complexType name=&quot;executorFactory&quot;&gt;
    &lt;xs:sequence&gt;
      &lt;xs:element name=&quot;properties&quot; type=&quot;tns:properties&quot; minOccurs=&quot;0&quot;&gt;
        &lt;xs:annotation&gt;
          &lt;xs:documentation&gt;
            Add key/value property pair to this factory configuration. Example properties include &quot;maxThreads&quot; which sets the maximum number of threads for this executor (default values can be found at https://docs.jboss.org/author/display/ISPN/Default+Values+For+Property+Based+Attribute). Another example is &quot;threadNamePrefix&quot; which sets the thread name prefix for threads created by this executor (default values can be found at https://docs.jboss.org/author/display/ISPN/Default+Values+For+Property+Based+Attributes).
          &lt;/xs:documentation&gt;
        &lt;/xs:annotation&gt;
      &lt;/xs:element&gt;
    &lt;/xs:sequence&gt;
    &lt;xs:attribute name=&quot;factory&quot; type=&quot;xs:string&quot;&gt;
      &lt;xs:annotation&gt;
        &lt;xs:documentation&gt;
          Fully qualified class name of the ExecutorFactory to use.  Must implement org.infinispan.executors.ExecutorFactory
        &lt;/xs:documentation&gt;
      &lt;/xs:annotation&gt;
    &lt;/xs:attribute&gt;
  &lt;/xs:complexType&gt;

  &lt;xs:complexType name=&quot;properties&quot;&gt;
    &lt;xs:sequence&gt;
      &lt;xs:element name=&quot;property&quot; minOccurs=&quot;0&quot; maxOccurs=&quot;unbounded&quot;&gt;
        &lt;xs:complexType&gt;
          &lt;xs:attribute name=&quot;name&quot; type=&quot;xs:string&quot;&gt;
            &lt;xs:annotation&gt;
              &lt;xs:documentation&gt;
                The property name or key
              &lt;/xs:documentation&gt;
            &lt;/xs:annotation&gt;
          &lt;/xs:attribute&gt;
          &lt;xs:attribute name=&quot;value&quot; type=&quot;xs:string&quot;&gt;
            &lt;xs:annotation&gt;
              &lt;xs:documentation&gt;
                The property value
              &lt;/xs:documentation&gt;
            &lt;/xs:annotation&gt;
          &lt;/xs:attribute&gt;
        &lt;/xs:complexType&gt;
      &lt;/xs:element&gt;
    &lt;/xs:sequence&gt;
  &lt;/xs:complexType&gt;

  &lt;xs:complexType name=&quot;scheduledExecutorFactory&quot;&gt;
    &lt;xs:sequence&gt;
       &lt;xs:element name=&quot;properties&quot; type=&quot;tns:properties&quot; minOccurs=&quot;0&quot;&gt;
         &lt;xs:annotation&gt;
            &lt;xs:documentation&gt;
               Add key/value property pair to this factory configuration. Example properties include &quot;maxThreads&quot; which sets the maximum number of threads for this executor (default values can be found at https://docs.jboss.org/author/display/ISPN/Default+Values+For+Property+Based+Attribute). Another example is &quot;threadNamePrefix&quot; which sets the thread name prefix for threads created by this executor (default values can be found at https://docs.jboss.org/author/display/ISPN/Default+Values+For+Property+Based+Attributes).
            &lt;/xs:documentation&gt;
         &lt;/xs:annotation&gt;
       &lt;/xs:element&gt;
     &lt;/xs:sequence&gt;
     &lt;xs:attribute name=&quot;factory&quot; type=&quot;xs:string&quot;&gt;
      &lt;xs:annotation&gt;
         &lt;xs:documentation&gt;
            Fully qualified class name of the ScheduledExecutorFactory to use.  Must implement org.infinispan.executors.ScheduledExecutorFactory
         &lt;/xs:documentation&gt;
      &lt;/xs:annotation&gt;
     &lt;/xs:attribute&gt;
  &lt;/xs:complexType&gt;

  &lt;xs:complexType name=&quot;backup&quot;&gt;
      &lt;xs:sequence minOccurs=&quot;0&quot; maxOccurs=&quot;1&quot;&gt;
          &lt;xs:element name=&quot;takeOffline&quot; minOccurs=&quot;0&quot;&gt;
              &lt;xs:annotation&gt;
                  &lt;xs:documentation&gt;
                      Determines whether this backup is taken offline (ignored) after a certain
                      number of tries.
                  &lt;/xs:documentation&gt;
              &lt;/xs:annotation&gt;
              &lt;xs:complexType&gt;
                  &lt;xs:attribute name=&quot;afterFailures&quot; type=&quot;xs:int&quot;&gt;
                      &lt;xs:annotation&gt;
                          &lt;xs:documentation&gt;
                              The number of failed request operations after which this site
                              should be taken offline. Defaults to 0 (never).
                              A negative value would mean that the site will be taken offline
                              after 'minTimeToWait'.
                          &lt;/xs:documentation&gt;
                      &lt;/xs:annotation&gt;
                  &lt;/xs:attribute&gt;
                  &lt;xs:attribute name=&quot;minTimeToWait&quot; type=&quot;xs:long&quot;&gt;
                      &lt;xs:annotation&gt;
                          &lt;xs:documentation&gt;
                              The minimal number of millis to wait before taking this site
                              offline, even in the case 'afterFailures' is reached.
                              If smaller or equal to 0, then only 'afterFailures' is considered.
                          &lt;/xs:documentation&gt;
                      &lt;/xs:annotation&gt;
                  &lt;/xs:attribute&gt;
              &lt;/xs:complexType&gt;
          &lt;/xs:element&gt;
      &lt;/xs:sequence&gt;
      &lt;xs:attribute name=&quot;site&quot; type=&quot;xs:string&quot; use=&quot;required&quot;&gt;
          &lt;xs:annotation&gt;
              &lt;xs:documentation&gt;
                  Name of the remote site where this cache backups data.
              &lt;/xs:documentation&gt;
          &lt;/xs:annotation&gt;
      &lt;/xs:attribute&gt;
      &lt;xs:attribute name=&quot;strategy&quot; use=&quot;optional&quot;&gt;
          &lt;xs:annotation&gt;
              &lt;xs:documentation&gt;
                  The strategy used for backing up data: &quot;SYNC&quot; or &quot;ASYNC&quot;. Defaults to &quot;ASYNC&quot;
              &lt;/xs:documentation&gt;
          &lt;/xs:annotation&gt;
          &lt;xs:simpleType&gt;
              &lt;xs:restriction base=&quot;xs:string&quot;&gt;
                  &lt;xs:enumeration value=&quot;SYNC&quot;/&gt;
                  &lt;xs:enumeration value=&quot;ASYNC&quot;/&gt;
              &lt;/xs:restriction&gt;
          &lt;/xs:simpleType&gt;
      &lt;/xs:attribute&gt;
      &lt;xs:attribute name=&quot;backupFailurePolicy&quot; use=&quot;optional&quot;&gt;
          &lt;xs:annotation&gt;
              &lt;xs:documentation&gt;
                  Decides what the system would do in case of failure during backup. Defaults to
                  &quot;FAIL&quot;
              &lt;/xs:documentation&gt;
          &lt;/xs:annotation&gt;
          &lt;xs:simpleType&gt;
              &lt;xs:restriction base=&quot;xs:string&quot;&gt;
                  &lt;xs:enumeration value=&quot;IGNORE&quot;/&gt;
                  &lt;xs:enumeration value=&quot;WARN&quot;/&gt;
                  &lt;xs:enumeration value=&quot;FAIL&quot;/&gt;
                  &lt;xs:enumeration value=&quot;CUSTOM&quot;/&gt;
              &lt;/xs:restriction&gt;
          &lt;/xs:simpleType&gt;
      &lt;/xs:attribute&gt;
      &lt;xs:attribute name=&quot;timeout&quot; use=&quot;optional&quot; type=&quot;xs:long&quot;&gt;
          &lt;xs:annotation&gt;
              &lt;xs:documentation&gt;
                  The timeout(millis) to be used when backing up data remotely. Defaults to 10
                  secs.
              &lt;/xs:documentation&gt;
          &lt;/xs:annotation&gt;
      &lt;/xs:attribute&gt;
      &lt;xs:attribute name=&quot;useTwoPhaseCommit&quot; use=&quot;optional&quot; type=&quot;xs:boolean&quot;&gt;
          &lt;xs:annotation&gt;
              &lt;xs:documentation&gt;
                  Whether a backup will use a 2PC cycle for SYNC backups.  Defaults to &quot;false&quot;.
                  NOTE: Not used for ASYNC backup strategies.
              &lt;/xs:documentation&gt;
          &lt;/xs:annotation&gt;
      &lt;/xs:attribute&gt;      
      &lt;xs:attribute name=&quot;failurePolicyClass&quot; use=&quot;optional&quot; type=&quot;xs:string&quot;&gt;
          &lt;xs:annotation&gt;
              &lt;xs:documentation&gt;
                  If the 'backupFailurePolicy' is set to 'CUSTOM' then this attribute is
                  required and should
                  contain the fully qualified name of a class implementing
                  org.infinispan.xsite.CustomFailurePolicy.
              &lt;/xs:documentation&gt;
          &lt;/xs:annotation&gt;
      &lt;/xs:attribute&gt;
      &lt;xs:attribute name=&quot;enabled&quot; type=&quot;xs:boolean&quot;&gt;
          &lt;xs:annotation&gt;
              &lt;xs:documentation&gt;
                  If 'false' then no data is backed up to this site. Defaults to 'true'.
              &lt;/xs:documentation&gt;
          &lt;/xs:annotation&gt;
      &lt;/xs:attribute&gt;
  &lt;/xs:complexType&gt;

  &lt;xs:complexType name=&quot;site&quot;&gt;
    &lt;xs:sequence minOccurs=&quot;0&quot; maxOccurs=&quot;unbounded&quot;&gt;
    &lt;/xs:sequence&gt;
    &lt;xs:attribute name=&quot;local&quot; type=&quot;xs:string&quot; use=&quot;required&quot;&gt;
      &lt;xs:annotation&gt;
        &lt;xs:documentation&gt;
          The name of the local site. Must be one of the site names defined in child &quot;site&quot; elements.
        &lt;/xs:documentation&gt;
      &lt;/xs:annotation&gt;
    &lt;/xs:attribute&gt;
  &lt;/xs:complexType&gt;

  &lt;xs:simpleType name=&quot;shutdownHookBehavior&quot;&gt;
    &lt;xs:restriction base=&quot;xs:string&quot;&gt;
      &lt;xs:enumeration value=&quot;DEFAULT&quot;/&gt;
      &lt;xs:enumeration value=&quot;REGISTER&quot;/&gt;
      &lt;xs:enumeration value=&quot;DONT_REGISTER&quot;/&gt;
    &lt;/xs:restriction&gt;
  &lt;/xs:simpleType&gt;

  &lt;xs:simpleType name=&quot;isolationLevel&quot;&gt;
    &lt;xs:restriction base=&quot;xs:string&quot;&gt;
      &lt;xs:enumeration value=&quot;NONE&quot;/&gt;
      &lt;xs:enumeration value=&quot;SERIALIZABLE&quot;/&gt;
      &lt;xs:enumeration value=&quot;REPEATABLE_READ&quot;/&gt;
      &lt;xs:enumeration value=&quot;READ_COMMITTED&quot;/&gt;
      &lt;xs:enumeration value=&quot;READ_UNCOMMITTED&quot;/&gt;
    &lt;/xs:restriction&gt;
  &lt;/xs:simpleType&gt;

  &lt;xs:simpleType name=&quot;evictionStrategy&quot;&gt;
    &lt;xs:restriction base=&quot;xs:string&quot;&gt;
      &lt;xs:enumeration value=&quot;NONE&quot;/&gt;
      &lt;xs:enumeration value=&quot;UNORDERED&quot;/&gt;
      &lt;xs:enumeration value=&quot;FIFO&quot;/&gt;
      &lt;xs:enumeration value=&quot;LRU&quot;/&gt;
      &lt;xs:enumeration value=&quot;LRU_OLD&quot;/&gt;
      &lt;xs:enumeration value=&quot;LIRS&quot;/&gt;
    &lt;/xs:restriction&gt;
  &lt;/xs:simpleType&gt;

  &lt;xs:simpleType name=&quot;evictionThreadPolicy&quot;&gt;
    &lt;xs:restriction base=&quot;xs:string&quot;&gt;
      &lt;xs:enumeration value=&quot;PIGGYBACK&quot;/&gt;
      &lt;xs:enumeration value=&quot;DEFAULT&quot;/&gt;
    &lt;/xs:restriction&gt;
  &lt;/xs:simpleType&gt;
  
  &lt;xs:simpleType name=&quot;lockingMode&quot;&gt;
    &lt;xs:annotation&gt;
      &lt;xs:documentation&gt;
        Defines the locking modes that are available for transactional caches: optimistic or pessimistic - see http://community.jboss.org/wiki/OptimisticLockingInInfinispan for more.
      &lt;/xs:documentation&gt;
    &lt;/xs:annotation&gt;
    &lt;xs:restriction base=&quot;xs:string&quot;&gt;
      &lt;xs:enumeration value=&quot;OPTIMISTIC&quot; /&gt;
      &lt;xs:enumeration value=&quot;PESSIMISTIC&quot; /&gt;
    &lt;/xs:restriction&gt;
  &lt;/xs:simpleType&gt;
  
  &lt;xs:simpleType name=&quot;transactionMode&quot;&gt;
    &lt;xs:annotation&gt;
      &lt;xs:documentation&gt;
        Enumeration containing the available transaction modes for a cache.
      &lt;/xs:documentation&gt;
    &lt;/xs:annotation&gt;
    &lt;xs:restriction base=&quot;xs:string&quot;&gt;
      &lt;xs:enumeration value=&quot;NON_TRANSACTIONAL&quot; /&gt;
      &lt;xs:enumeration value=&quot;TRANSACTIONAL&quot; /&gt;
    &lt;/xs:restriction&gt;
  &lt;/xs:simpleType&gt;

  &lt;xs:complexType name=&quot;loader&quot; abstract=&quot;true&quot;&gt;
    &lt;xs:sequence&gt;
      &lt;xs:element name=&quot;properties&quot; type=&quot;tns:properties&quot; minOccurs=&quot;0&quot;&gt;
        &lt;xs:annotation&gt;
          &lt;xs:documentation&gt;
            Properties passed to the cache store or loader
          &lt;/xs:documentation&gt;
        &lt;/xs:annotation&gt;
      &lt;/xs:element&gt;
    &lt;/xs:sequence&gt;
  &lt;/xs:complexType&gt;

  &lt;xs:complexType name=&quot;customLoader&quot;&gt;
    &lt;xs:complexContent&gt;
      &lt;xs:extension base=&quot;tns:loader&quot;&gt;
        &lt;xs:attribute name=&quot;class&quot; type=&quot;xs:string&quot;&gt;
          &lt;xs:annotation&gt;
            &lt;xs:documentation&gt;
              The cache loader to configure and use
            &lt;/xs:documentation&gt;
          &lt;/xs:annotation&gt;
        &lt;/xs:attribute&gt;
      &lt;/xs:extension&gt;
    &lt;/xs:complexContent&gt;
  &lt;/xs:complexType&gt;

  &lt;xs:complexType name=&quot;async&quot;&gt;
    &lt;xs:attribute name=&quot;enabled&quot; type=&quot;xs:boolean&quot;&gt;
      &lt;xs:annotation&gt;
        &lt;xs:documentation&gt;
          If true, all modifications to this cache store happen asynchronously, on a separate thread.
        &lt;/xs:documentation&gt;
      &lt;/xs:annotation&gt;
    &lt;/xs:attribute&gt;
    &lt;xs:attribute name=&quot;flushLockTimeout&quot; type=&quot;xs:long&quot;&gt;
      &lt;xs:annotation&gt;
        &lt;xs:documentation&gt;
          Timeout to acquire the lock which guards the state to be flushed to the cache store periodically.
        &lt;/xs:documentation&gt;
      &lt;/xs:annotation&gt;
    &lt;/xs:attribute&gt;
    &lt;xs:attribute name=&quot;modificationQueueSize&quot; type=&quot;xs:int&quot;&gt;
      &lt;xs:annotation&gt;
        &lt;xs:documentation&gt;
          Sets the size of the modification queue for the async store. If updates are made at a rate that is faster than the underlying cache store can process this queue, then the async
          store behaves like a synchronous store for that period, blocking until the queue can accept more elements.
        &lt;/xs:documentation&gt;
      &lt;/xs:annotation&gt;
    &lt;/xs:attribute&gt;
    &lt;xs:attribute name=&quot;shutdownTimeout&quot; type=&quot;xs:long&quot;&gt;
      &lt;xs:annotation&gt;
        &lt;xs:documentation&gt;
          Timeout to stop the cache store. When the store is stopped it's possible that some modifications still need to be applied; you likely want to set a very large timeout to make sure to
          not loose data
        &lt;/xs:documentation&gt;
      &lt;/xs:annotation&gt;
    &lt;/xs:attribute&gt;
    &lt;xs:attribute name=&quot;threadPoolSize&quot; type=&quot;xs:int&quot;&gt;
      &lt;xs:annotation&gt;
        &lt;xs:documentation&gt;
          Size of the thread pool whose threads are responsible for applying the modifications.
        &lt;/xs:documentation&gt;
      &lt;/xs:annotation&gt;
    &lt;/xs:attribute&gt;
  &lt;/xs:complexType&gt;

  &lt;xs:complexType name=&quot;singletonStore&quot;&gt;
    &lt;xs:attribute name=&quot;pushStateTimeout&quot; type=&quot;xs:long&quot;&gt;
      &lt;xs:annotation&gt;
        &lt;xs:documentation&gt;
          If pushStateWhenCoordinator is true, this property sets the maximum number of milliseconds that the process of pushing the in-memory state to the underlying cache loader should
          take.
        &lt;/xs:documentation&gt;
      &lt;/xs:annotation&gt;
    &lt;/xs:attribute&gt;
    &lt;xs:attribute name=&quot;pushStateWhenCoordinator&quot; type=&quot;xs:boolean&quot;&gt;
      &lt;xs:annotation&gt;
        &lt;xs:documentation&gt;
          If true, when a node becomes the coordinator, it will transfer in-memory state to the underlying cache store. This can be very useful in situations where the coordinator crashes
          and there's a gap in time until the new coordinator is elected.
        &lt;/xs:documentation&gt;
      &lt;/xs:annotation&gt;
    &lt;/xs:attribute&gt;
    &lt;xs:attribute name=&quot;enabled&quot; type=&quot;xs:boolean&quot;&gt;
      &lt;xs:annotation&gt;
        &lt;xs:documentation&gt;
          If true, the singleton store cache store is enabled.
        &lt;/xs:documentation&gt;
      &lt;/xs:annotation&gt;
    &lt;/xs:attribute&gt;
  &lt;/xs:complexType&gt;

  &lt;xs:complexType name=&quot;store&quot; abstract=&quot;true&quot;&gt;
    &lt;xs:complexContent&gt;
      &lt;xs:extension base=&quot;tns:loader&quot;&gt;
        &lt;xs:sequence&gt;
          &lt;xs:element name=&quot;async&quot; type=&quot;tns:async&quot; minOccurs=&quot;0&quot; maxOccurs=&quot;1&quot;&gt;
            &lt;xs:annotation&gt;
              &lt;xs:documentation&gt;
                Configuration for the async cache loader. If enabled, this provides you with asynchronous writes to the cache store, giving you 'write-behind' caching.
              &lt;/xs:documentation&gt;
            &lt;/xs:annotation&gt;
          &lt;/xs:element&gt;
          &lt;xs:element name=&quot;singletonStore&quot; type=&quot;tns:singletonStore&quot; minOccurs=&quot;0&quot; maxOccurs=&quot;1&quot;&gt;
            &lt;xs:annotation&gt;
              &lt;xs:documentation&gt;
                SingletonStore is a delegating cache store used for situations when only one instance in a cluster should interact with the underlying store. The coordinator of the cluster will be responsible for the underlying CacheStore. SingletonStore is a simply facade to a real CacheStore implementation. It always delegates reads to the real CacheStore.
              &lt;/xs:documentation&gt;
            &lt;/xs:annotation&gt;
          &lt;/xs:element&gt;
        &lt;/xs:sequence&gt;
        &lt;xs:attribute name=&quot;fetchPersistentState&quot; type=&quot;xs:boolean&quot;&gt;
          &lt;xs:annotation&gt;
            &lt;xs:documentation&gt;
              If true, fetch persistent state when joining a cluster. If multiple cache stores are chained, only one of them can have this property enabled. Persistent state transfer with a shared cache store does not make sense, as the same
              persistent store that provides the data will just end up receiving it. Therefore, if a shared cache store is used, the cache will not allow a persistent state transfer even if a cache store has this
              property set to true. Finally, setting it to true only makes sense if in a clustered environment, and only 'replication' and 'invalidation' cluster modes are supported.
            &lt;/xs:documentation&gt;
          &lt;/xs:annotation&gt;
        &lt;/xs:attribute&gt;
        &lt;xs:attribute name=&quot;ignoreModifications&quot; type=&quot;xs:boolean&quot;&gt;
          &lt;xs:annotation&gt;
            &lt;xs:documentation&gt;
              If true, any operation that modifies the cache (put, remove, clear, store...etc) won't be applied to the cache store. This means that the cache store could become out of sync with the cache.
            &lt;/xs:documentation&gt;
          &lt;/xs:annotation&gt;
        &lt;/xs:attribute&gt;
        &lt;xs:attribute name=&quot;purgeOnStartup&quot; type=&quot;xs:boolean&quot;&gt;
          &lt;xs:annotation&gt;
            &lt;xs:documentation&gt;
              If true, purges this cache store
              when it starts up.
            &lt;/xs:documentation&gt;
          &lt;/xs:annotation&gt;
        &lt;/xs:attribute&gt;
        &lt;xs:attribute name=&quot;purgeSynchronously&quot; type=&quot;xs:boolean&quot;&gt;
          &lt;xs:annotation&gt;
            &lt;xs:documentation&gt;
              If true, CacheStore#purgeExpired() call will be done synchronously
            &lt;/xs:documentation&gt;
          &lt;/xs:annotation&gt;
        &lt;/xs:attribute&gt;
        &lt;xs:attribute name=&quot;purgerThreads&quot; type=&quot;xs:int&quot;&gt;
          &lt;xs:annotation&gt;
            &lt;xs:documentation&gt;
              The number of threads to use when purging asynchronously.
            &lt;/xs:documentation&gt;
          &lt;/xs:annotation&gt;
        &lt;/xs:attribute&gt;
      &lt;/xs:extension&gt;
    &lt;/xs:complexContent&gt;
  &lt;/xs:complexType&gt;
  
  &lt;xs:complexType name=&quot;lockSupportStore&quot;&gt;
    &lt;xs:complexContent&gt;
      &lt;xs:extension base=&quot;tns:store&quot;&gt;
        &lt;xs:attribute name=&quot;lockAcquisitionTimeout&quot; type=&quot;xs:long&quot;&gt;
            &lt;xs:annotation&gt;
              &lt;xs:documentation&gt;
                Maximum time to attempt a particular lock acquisition
              &lt;/xs:documentation&gt;
            &lt;/xs:annotation&gt;
          &lt;/xs:attribute&gt;
          &lt;xs:attribute name=&quot;concurrencyLevel&quot; type=&quot;xs:int&quot;&gt;
            &lt;xs:annotation&gt;
              &lt;xs:documentation&gt;
                Concurrency level for lock containers. Adjust this value according to the number of concurrent threads interacting with Infinispan. Similar to the concurrencyLevel tuning parameter seen in the JDK's ConcurrentHashMap.
              &lt;/xs:documentation&gt;
            &lt;/xs:annotation&gt;
          &lt;/xs:attribute&gt;
      &lt;/xs:extension&gt;
    &lt;/xs:complexContent&gt;
  &lt;/xs:complexType&gt;
  
  &lt;xs:complexType name=&quot;customStore&quot;&gt;
    &lt;xs:complexContent&gt;
      &lt;xs:extension base=&quot;tns:lockSupportStore&quot;&gt;
        &lt;xs:attribute name=&quot;class&quot; type=&quot;xs:string&quot;&gt;
          &lt;xs:annotation&gt;
            &lt;xs:documentation&gt;
              The cache store to configure and use
            &lt;/xs:documentation&gt;
          &lt;/xs:annotation&gt;
        &lt;/xs:attribute&gt;
      &lt;/xs:extension&gt;
    &lt;/xs:complexContent&gt;
  &lt;/xs:complexType&gt;
  
  &lt;xs:complexType name=&quot;clusterLoader&quot;&gt;
    &lt;xs:complexContent&gt;
      &lt;xs:extension base=&quot;tns:loader&quot;&gt;
        &lt;xs:attribute name=&quot;remoteCallTimeout&quot;&gt;
          &lt;xs:annotation&gt;
            &lt;xs:documentation&gt;
              How long to wait for results from other members in the cluster before returning a null.
            &lt;/xs:documentation&gt;
          &lt;/xs:annotation&gt;
        &lt;/xs:attribute&gt;
      &lt;/xs:extension&gt;
    &lt;/xs:complexContent&gt;
  &lt;/xs:complexType&gt;
  
  &lt;xs:complexType name=&quot;fileStore&quot;&gt;
    &lt;xs:complexContent&gt;
      &lt;xs:extension base=&quot;tns:lockSupportStore&quot;&gt;
        &lt;xs:attribute name=&quot;location&quot; type=&quot;xs:string&quot;&gt;
          &lt;xs:annotation&gt;
            &lt;xs:documentation&gt;
              A location on disk where the store can write internal files.  This defaults to Infinispan-FileCacheStore in the current working directory.
            &lt;/xs:documentation&gt;
          &lt;/xs:annotation&gt;
        &lt;/xs:attribute&gt;
        &lt;xs:attribute name=&quot;streamBufferSize&quot; type=&quot;xs:int&quot;&gt;
          &lt;xs:annotation&gt;
            &lt;xs:documentation&gt;
              When writing state to disk, a buffered stream is used.  This parameter allows you to tune the buffer size.  Larger buffers are usually faster but take up more (temporary) memory, resulting in more gc. By default, this is set to 8192
            &lt;/xs:documentation&gt;
          &lt;/xs:annotation&gt;
        &lt;/xs:attribute&gt;
        &lt;xs:attribute name=&quot;fsyncMode&quot; type=&quot;tns:fsyncMode&quot;&gt;
          &lt;xs:annotation&gt;
            &lt;xs:documentation&gt;
              Configures how the file changes will be synchronized with the underlying file system. This property has three possible values (The default mode configured is default)
            &lt;/xs:documentation&gt;
          &lt;/xs:annotation&gt;
        &lt;/xs:attribute&gt;
        &lt;xs:attribute name=&quot;fsyncInterval&quot; type=&quot;xs:long&quot;&gt;
          &lt;xs:annotation&gt;
            &lt;xs:documentation&gt;
              Specifies the time after which the file changes in the cache need to be flushed. This option has only effect when periodic fsync mode is in use. The default fsync interval is 1 second.
            &lt;/xs:documentation&gt;
          &lt;/xs:annotation&gt;
        &lt;/xs:attribute&gt;
      &lt;/xs:extension&gt;
    &lt;/xs:complexContent&gt;
  &lt;/xs:complexType&gt;
  
  &lt;xs:simpleType name=&quot;fsyncMode&quot;&gt;
    &lt;xs:restriction base=&quot;xs:string&quot;&gt;
      &lt;xs:enumeration value=&quot;DEFAULT&quot;&gt;
        &lt;xs:annotation&gt;
          &lt;xs:documentation&gt;
            Means that the file system will be synchronized when the OS buffer is full or when the bucket is read.
          &lt;/xs:documentation&gt;
        &lt;/xs:annotation&gt;
      &lt;/xs:enumeration&gt;
      &lt;xs:enumeration value=&quot;PER_WRITE&quot;&gt;
        &lt;xs:annotation&gt;
          &lt;xs:documentation&gt;
            Configures the file cache store to sync up changes after each write request
          &lt;/xs:documentation&gt;
        &lt;/xs:annotation&gt;
      &lt;/xs:enumeration&gt;
      &lt;xs:enumeration value=&quot;PERIODIC&quot;&gt;
        &lt;xs:annotation&gt;
          &lt;xs:documentation&gt;
            Enables sync operations to happen as per a defined interval, or when the bucket is about to be read.
          &lt;/xs:documentation&gt;
        &lt;/xs:annotation&gt;
      &lt;/xs:enumeration&gt;
    &lt;/xs:restriction&gt;
  &lt;/xs:simpleType&gt;
  
  &lt;xs:simpleType name=&quot;versioningScheme&quot;&gt;
    &lt;xs:restriction base=&quot;xs:string&quot;&gt;
      &lt;xs:enumeration value=&quot;SIMPLE&quot;&gt;
        &lt;xs:annotation&gt;
          &lt;xs:documentation&gt;
           A simple versioning scheme that is cluster-aware
          &lt;/xs:documentation&gt;
        &lt;/xs:annotation&gt;
      &lt;/xs:enumeration&gt;
      &lt;xs:enumeration value=&quot;NONE&quot;&gt;
        &lt;xs:annotation&gt;
          &lt;xs:documentation&gt;
            Don't version entries
          &lt;/xs:documentation&gt;
        &lt;/xs:annotation&gt;
      &lt;/xs:enumeration&gt;
    &lt;/xs:restriction&gt;
  &lt;/xs:simpleType&gt;
&lt;/xs:schema&gt;

</pre></div></div>
                <div id='entity-decl-context-menu' class='context-menu-panel' style='visibility: hidden;'></div>
                <div id='entity-decl-context-menu-data' style='visibility: hidden;'></div>

                <div id="bug-popup-div" class="bug-popup" style="visibility: hidden;">
                    <span id="bug-message-span"></span>
                </div>

                
                
                <div id="ad-container">
                    <script>
                    function findPre(el) {
                        var children = el.childNodes;
                        for(var i = 0; i < children.length; ++i) {
                            var c = children[i];
                            if (c.tagName == "PRE") {
                                return c;
                            }
                        }
                        return null;
                    }

                    function getLines() {
                        if (document.getElementsByClassName) {
                        	return document.getElementsByClassName("line");
                        } else {
                            var lines = new Array();
                            divs = document.getElementsByTagName("div");
                            for(var i = 0; i < divs.length; ++i) {
                                if (divs[i].className == "line") {
                                    lines[lines.length] = divs[i];
                                }
                            }
                            return lines;
                        }
                    }

                    function findContigousAdSpace() {
                        var lineElems = getLines();
                        var regions = new Array();
                        var inRegion = false;
                        var lastLine = -1;
                        var currRegion = null;
                        for(var i = 0; i < lineElems.length; ++i) {
                            var d = lineElems[i];
                            var did = d.id;
                            if (!did || !did.substr(0, 5) == "line-") {
                                continue;
                            }
                            var line = parseInt(did.substr(5));
                            var pre = findPre(d);
                            if (lastLine + 1 == line) {
                                if (pre) {
                                    currRegion.xEnd = currRegion.xEnd < pre.offsetWidth ? pre.offsetWidth : currRegion.xEnd;
                                    currRegion.yEnd = getPageOffsetBottom(pre) - getPageOffsetTop(document.getElementById('source-view'));
                                }
                            } else {
                                if (currRegion) {
                                    regions[regions.length] = currRegion;
                                }
                                if (pre) {
                                    currRegion = { };
                                    currRegion.xEnd = pre.offsetWidth;
                                    currRegion.yBegin = getPageOffsetTop(pre) - getPageOffsetTop(document.getElementById('source-view'));
                                }
                            }
                            lastLine = line;
                        }
                        if (currRegion) {
                            regions[regions.length] = currRegion;
                        }
                        return regions;
                    }

                    function show160x600Ad(divWidth, region) {
                        var j = region.yBegin + 20;
                        if (j + 600 < region.yEnd) {
                            if (region.xEnd > divWidth - 200) {
                                return false;
                            }
                            document.write('<div style="position: absolute; right: 0px; top: ' + j + 'px; z-index: 2; width: 185px; height: 610px"><div style="position: relative;">'
                                    + get160x600Ad()
                                    + '</div></div>');
                            region.yBegin = j + 600;
                            return true;
                        }
                        return false;
                    }
                    
                    function show120x240Ad(divWidth, region) {
                        var j = region.yBegin + 20;
                        if (j + 240 < region.yEnd) {
                            if (region.xEnd > divWidth - 200) {
                                return false;
                            }
                            document.write('<div style="position: absolute; right: 0px; top: ' + j + 'px; z-index: 2; width: 145px; height: 250px"><div style="position: relative;">'
                                    + get120x240Ad()
                                    + '</div></div>');
                            region.yBegin = j + 240;
                            return true;
                        }
                        return false;
                    }

                    function show160x90LinkUnitAd(divWidth, region) {
                        var j = region.yBegin + 20;
                        if (j + 90 < region.yEnd) {
                            if (region.xEnd > divWidth - 200) {
                                return false;
                            }
                            document.write('<div style="position: absolute; right: 0px; top: ' + j + 'px; z-index: 2; width: 185px; height: 100px"><div style="position: relative;">'
                                    + get160x90LinkUnitAd()
                                    + '</div></div>');
                            region.yBegin = j + 90;
                            return true;
                        }
                        return false;
                    }

                    function showAds() {
                        var units = [[ show160x600Ad, show120x240Ad ], [ show160x90LinkUnitAd ]]
                        var regions = findContigousAdSpace();
                        var num = 0;
                        var divWidth = getPageOffsetRight(document.getElementById('source-view')) - getPageOffsetLeft(document.getElementById('source-view'));
                        for(var unit = 0; unit < units.length; ++unit) {
                            var ads = units[unit];
                            var num = 0;
                            var maxNAds = 3;
                            for(var a = 0; a < ads.length; ++a) {
                                if (num >= maxNAds) {
                                    break;
                                }
                                for(var i = 0; i < regions.length; ++i) {
                                    if (num >= maxNAds) {
                                        break;
                                    }
                                    while(true) {
                                        if (num >= maxNAds) {
                                            break;
                                        }
                                        if (!ads[a](divWidth, regions[i])) {
                                            break;
                                        }
                                        ++num;
                                    }
                                }
                            }
                        }
                    }
                    if (!isBrowserMSIE()) {
                        showAds();
                    }
                    </script>
                </div>
                
            </div>
        </div>
    </div>
    <div style="display: none;" id="outline-view-div">
        <div class="outline-header">
            <form name="profileform">
            <label for="profile">Profile: </label>
            <select name="profile" onchange="setProfile(this.value);" id="profilechanger">
                <option value="jre">Standard JRE</option>
                <option value="gae">Google AppEngine</option>
            </select>
            </form>
        </div>
        
    </div>
    <div style="display: none;" id="th-view-div">
        
    </div>
    <script type="text/javascript">pageTracker._setCustomVar(1, 'p-uri', 'http://www.infinispan.org', 3);</script>
    <script>
    function render(msgPre, evidenceId, currentId) {
        var currentParts = currentId.split("@");
        if (evidenceId == "") {
            return currentParts.length == 5 ? (msgPre + " as indicated by Google AppEngine Whitelist") : "";
        }
        var parts = evidenceId.split("@");
        if (parts.length == 5) {
            var prefix = "Uses";
            if (currentParts[3] == parts[3] && (currentParts[4] + ".").substring(0, parts[4].length + 1) == (parts[4] + ".")) {
                prefix = "Contained in";
            }
            return prefix + " type " + (parts[3] + "." + parts[4]).replace(/\$/g, ".");
        } else if (parts.length == 6) {
            return "Uses method " + parts[5] + " in type " + (parts[3] + "." + parts[4]).replace("$", ".");            
        }
        return "";
    }
    
    function doProfileRegistration(event, dummy, data) {
        var gaepc = data[0];

        for(i = 0; i < gaepc[2].length; ++i) {
            var m = gaepc[2][i];
            if (m.length >= 3) {
                var div = document.getElementById("gae-status-" + m[0]);
                if (div) {
                    if ("NONE" == m[1]) {
                        div.innerHTML = "<img class='img_base img_jdt_obj16_never_translate' src='/static/app/images/1x1.gif' border='0' title='"+ render("No support", m[2], m[0]) + "' width='16' height='16'></img>";
                    } else if ("PARTIAL" == m[1]) {
                        div.innerHTML = "<img class='img_base img_jdt_obj16_warning_obj' src='/static/app/images/1x1.gif' border='0' title='"+ render("Partial support", m[2], m[0]) + "' width='16' height='16'></img>";
                    }
                }
            }
        }
    }

    function registerProfileCompatibility(data) {
        YAHOO.util.Event.onDOMReady(doProfileRegistration, data);
    }

    function setInitialProfile() {
        var profileId = getRequestParameter('pr');
        var profileChooser = document.getElementById("profilechanger");

        if (profileChooser != null) {
            var options = profileChooser.options;
            for (var i=0; i<options.length; i=i+1) {
                if (options[i].value == profileId) {
                    options[i].selected = true;
                    setProfile(profileId);
                    return;
                }
            }
        }
    }

    function setProfile(value) {
        if ("gae" == value) {
            var el = YAHOO.util.Dom.getElementsByClassName("gae-status");            
            YAHOO.util.Dom.replaceClass(el, "gae-status", "gae-status-enabled");            
        } else {
            el = YAHOO.util.Dom.getElementsByClassName("gae-status-enabled");
            YAHOO.util.Dom.replaceClass(el, "gae-status-enabled", "gae-status");            
        }
    }

    var markElement = null;
    var scheduledMarkId = null;

    function scheduleMark(el) {
        if (scheduledMarkId != null) {
            unscheduleMark(null)
        }
        markElement = el;
        scheduledMarkId = setInterval("mark(markElement);", 500);
    }

    function unscheduleMark(el) {
        if (scheduledMarkId != null) {
            clearInterval(scheduledMarkId);
            scheduledMarkId = null;
        }
    }

    function mark(el) {
        var classAttribute = getClassAttribute(el);
        var weight = getWeight(classAttribute);
        if (weight == "0") {
            el.style.background = "#fb8";
        }
        else {
            el.style.background = "#ddd";
        }
    
        var markWithoutWeight = removeWeight(classAttribute);
    
        var spanElems = document.getElementsByTagName("span");
        for (i = 0; i < spanElems.length; i++) {        
            var spanClassAttribute = getClassAttribute(spanElems[i]);
            if (spanClassAttribute && isMark(spanClassAttribute)) {
                if (markWithoutWeight == removeWeight(spanClassAttribute)) {            
                    var spanWeight = getWeight(spanClassAttribute);
                    if (spanWeight == "0") {
                        spanElems[i].style.background = "#fb8";
                    }
                    else {
                        spanElems[i].style.background = "#ddd";
                    }
                }
                else {
                    spanElems[i].style.background = "";
                }       
            }   
        }    
    }

    function demark(el) {
        el.style.background = "white";
        var spanElems = document.getElementsByTagName("span");
        for (i = 0; i < spanElems.length; i++) {
            if (getClassAttribute(el) == getClassAttribute(spanElems[i])) {
                spanElems[i].style.background = ""; 
            }
        }
    }

    function removeWeight(s) {
        return s.substring(0, s.indexOf('#'));
    }

    function getWeight(s) {
        return s.substring(s.indexOf('#')+1);
    }

    function isMark(s) {
        return (s.length > 5) && (s.substring(0, 5) == "mark-");
    }
    </script>
    <div style="display: none;" id="pc-div">
        
    </div>

    <script>
    var bugPopUpOn = -1;
    var bugs = [];

    function showbug(marker, index) {
        var bugPopupDiv = document.getElementById('bug-popup-div');
        var bugMsgSpan = document.getElementById('bug-message-span');
        var startIndex = index - 1;
        while(startIndex >= 0 && bugs[startIndex].sl == bugs[index].sl) {
            --startIndex;
        }
        ++startIndex;
        var str = '';
        for(var i = startIndex; i <= index; ++i) {
            var bug = bugs[i];
            if (bug.el > 0 && bug.el != bug.sl) {
                str += 'Lines ' + bug.sl + '-' + bug.el;
            } else {
                str += 'Line ' + bug.sl;
            }
            str += ': ' + bug.m + '<br/>';
        }
        bugMsgSpan.innerHTML = str;
        bugPopupDiv.style.left = (marker.offsetLeft + 20) + 'px';
        bugPopupDiv.style.top = (marker.offsetTop + 20) + 'px';
        bugPopupDiv.style.visibility = 'visible';        
    }

    function hidebug() {
        var bugPopupDiv = document.getElementById('bug-popup-div');
        bugPopupDiv.style.visibility = 'hidden';
    }

    function cmpBugs(b1, b2) {
        return b1.sl - b2.sl;
    }

    function showBugs() {
        bugs = eval(document.getElementById('bugs').innerHTML).sort(cmpBugs);
        for (var i=0, ln=bugs.length; i<ln; ++i) {
            var lnm = findBugLnm(i);
            if (lnm) {
                var nextBug = findNextBugWithLnm(i);
                var nextBugHref = nextBug ? "#" + nextBug.sl : "#";
                lnm.innerHTML = 
                    "<a href=\""+nextBugHref+"\" onmouseover=\"showbug(this,"+i+");\" onmouseout=\"hidebug();\">"+
                    "<img width=\"16\" height=\"16\" src=\"/static/app/images/debug_persp.gif\" style=\"border-style: none;\"></img>"+
                    "</a>";
            }
        }
    }
    YAHOO.util.Event.onDOMReady(showBugs, null, true);

    function findBugLnm(bugIdx) {
        var bug = bugs[bugIdx];
        if (bug.sl > 0) {
            var lnm = document.getElementById('lnml-' + bug.sl);
            if (lnm) {
                return lnm;
            }
        }
        return null;
    }

    function findNextBugWithLnm(bugIdx) {
        var sl = bugs[bugIdx].sl;
        for (var i = bugIdx+1, ln=bugs.length; i<ln; i++) {
            if (bugs[i].sl > sl) {
                var lnm = findBugLnm(i);
                if (lnm) {
                    return bugs[i];
                }
            }
        }
        return null;
    }
    
    function triggerLineHotspot(line) {
        var imgTag = document.getElementById('lnhs-' + line);
        if (imgTag) {
            imgTag.src = '/static/app/images/html_tag_obj.gif';
        }
    }

    function untriggerLineHotspot(line) {
        var imgTag = document.getElementById('lnhs-' + line);
        if (imgTag) {
            imgTag.src = '/static/app/images/1x1.gif';
        }
    }
    
    function showStackOverflowQuestions() {
        document.getElementById('page-mask').style.visibility = 'visible';
        var dropdown = document.getElementById('so-question-panel');
        if (dropdown) {
            dropdown.style.display = 'block';
            var x = (getWindowWidth() - dropdown.offsetWidth) / 2;
            var y = (getWindowHeight() - dropdown.offsetHeight) / 2;
            dropdown.style.left = x + 'px';
            dropdown.style.top = y + 'px';
            dropdown.style.visibility = 'visible';
        }
    }

    function hideStackOverflowQuestions() {
        var dropdown = document.getElementById('so-question-panel');
        if (dropdown) {
            dropdown.style.visibility = 'hidden';
            dropdown.style.display = 'none';
        }
        document.getElementById('page-mask').style.visibility = 'hidden';
    }

    function showSnippetDialog(line) {
        showSnippetDialogFromTo(line, line);
    }

    function showSnippetDialogFromTo(from, to) {
        document.getElementById('page-mask').style.visibility = 'visible';
        var dropdown = document.getElementById('snippet-dropdown');
        dropdown.style.display = 'block';
        var x = (getWindowWidth() - dropdown.offsetWidth) / 2;
        var y = (getWindowHeight() - dropdown.offsetHeight) / 2;
        dropdown.style.left = x + 'px';
        dropdown.style.top = y + 'px';
        dropdown.style.visibility = 'visible';
        var form = document.getElementById('snippet-form');
        form.snippet_start.value = from;
        form.snippet_end.value = to;
        fetchSnippet();
    }

    function hideSnippetDialog() {
        var dropdown = document.getElementById('snippet-dropdown');
        dropdown.style.visibility = 'hidden';
        dropdown.style.display = 'none';
        document.getElementById('page-mask').style.visibility = 'hidden';
    }
    
    function escKeyListener() {
        hideSnippetDialog();
        hideStackOverflowQuestions();
    }

    keyListener = new YAHOO.util.KeyListener(document, {keys:[27]}, escKeyListener);
    YAHOO.util.Event.onDOMReady(keyListener.enable, keyListener, true);
        
    
    function incFromLine() {
        var form = document.getElementById('snippet-form');
        var start = form.snippet_start.value;
        var startNum = parseInt(start);
        form.snippet_start.value = startNum + 1
        var end = form.snippet_end.value;
        var endNum = parseInt(end);
        if (endNum < startNum + 1) {
            form.snippet_end.value = form.snippet_start.value;
        }
        fetchSnippet();
    }

    function decFromLine() {
        var form = document.getElementById('snippet-form');
        var start = form.snippet_start.value;
        var startNum = parseInt(start);
        form.snippet_start.value = startNum <= 1 ? 1 : (startNum - 1);
        fetchSnippet();
    }

    function incToLine() {
        var form = document.getElementById('snippet-form');
        var end = form.snippet_end.value;
        var endNum = parseInt(end);
        form.snippet_end.value = endNum + 1;
        fetchSnippet();
    }

    function decToLine() {
        var form = document.getElementById('snippet-form');
        var end = form.snippet_end.value;
        var endNum = parseInt(end);
        form.snippet_end.value = endNum <= 1 ? 1 : (endNum - 1);
        var start = form.snippet_start.value;
        var startNum = parseInt(start);
        if (endNum - 1 < startNum) {
            form.snippet_start.value = form.snippet_end.value;
        }
        fetchSnippet();
    }

    function fetchSnippet() {
        var preview = document.getElementById('snippet-preview');
        var form = document.getElementById('snippet-form');
        var start = form.snippet_start.value;
        var end = form.snippet_end.value;
        var startNum = parseInt(start);
        var endNum = parseInt(end);
        var length = endNum - startNum + 1;

        var sUrl = location.protocol+"//"+location.host+location.pathname+
                   "?fragment=line&start="+start+"&length="+length;

        var callback = {
            success: function(oResponse) {
                var snippet = oResponse.responseText;
                preview.innerHTML = snippet;
                form.snippet_html.value = snippet;
                form.snippet_html.select();
                form.snippet_html.focus();
            },

            failure: function(oResponse) {
                preview.innerHTML = "";
                form.snippet_html.value = "";
            },

            timeout: 7000
        };

        YAHOO.util.Connect.asyncRequest('GET', sUrl, callback);
    }

    fileSource = function() {
    	var leftTabView;

    	function getOutlineHTML() {
        	var outlineDiv = document.getElementById("outline-view-div");
        	var html = outlineDiv.innerHTML;
        	outlineDiv.innerHTML = "";
        	return html;
    	}

        function addTabs() {
            var allviews = document.getElementById('allviews_hidden').innerHTML;
            var activeview = document.getElementById('activeview_hidden').innerHTML;

            leftTabView = new YAHOO.widget.TabView();

            if (allviews.indexOf('o') >= 0) {
                leftTabView.addTab( new YAHOO.widget.Tab({
                    label: 'Outline',
                    content: getOutlineHTML(),
                    cacheData: true,
                    active: activeview == 'o'
                }));
            }

            leftTabView.addTab( new YAHOO.widget.Tab({
                label: 'Files',
                content: '<div class="file-nav-tree-container"><div id="treeDiv"></div></div>',
                cacheData: true,
                active: activeview == 'f'
            }));

            if (allviews.indexOf('h') >=0 ) {
                leftTabView.addTab( new YAHOO.widget.Tab({
                    label: 'Hierarchy',
                    content: document.getElementById("th-view-div").innerHTML,
                    cacheData: true,
                    active: activeview == 'h'
                }));
            }
         
            if (!isGCEnterpriseEdition() && !isBrowserMSIE7() && !isBrowserMSIE6()) {   
                var commentURL = window.location.protocol + "//grepcode.com" + window.location.pathname;
            
                leftTabView.addTab(new YAHOO.widget.Tab({
                    label: 'Comments',
                    content: '<div class="fb-comments" data-href=' + commentURL + ' data-num-posts="20" data-width="380"></div>',
                    cacheData: false,
                    active: false
                }));
            }

            if (bugs.length > 0) {
                var links = "<ul class='bug-list'>";
                for(var i = 0; i < bugs.length; ++i) {
                    var bug = bugs[i];
                    var str = bug.m;
                    if (bug.sl > 0) {
                        var lnm = document.getElementById('lnml-' + bug.sl);
                        if (lnm) {
                            str = '<div class="bug-message">'+
                                    '<div class="ln"><a href="#' + bug.sl + '">' + bug.sl + '</a></div>'+': '+str+
                                  '</div>';
                        }
                    }
                    links += "<li class='bug-item'><span>" + str + "</span></li>";
                }
                links += "</ul>";
                var bugsTab = new YAHOO.widget.Tab({
                    label: 'Bugs (' + bugs.length + ')',
                    content: links,
                    active: activeview == 'b'
                });

                bugsTab.addListener('click', function(e) {
                    for (var i=0, ln=bugs.length; i<ln; ++i) {
                        var lnm = findBugLnm(i);
                        if (lnm) {
                            var ch = lnm.childNodes[0];
                            ch.focus();
                            break;
                        }
                    }
                });

                leftTabView.addTab(bugsTab);
            }

            leftTabView.appendTo('file-nav-tabs');
        }
    
        return {
            init: function() {
                addTabs();
                setInitialProfile();
            }
        };
    }();

    YAHOO.util.Event.onDOMReady(fileSource.init, fileSource, true);
    
    YAHOO.util.Event.onDOMReady(projectTree.init, projectTree, true);
    
    function setDimensions() {
        var fNavDiv = document.getElementById('file-nav-panel');
        var fSrcDiv = document.getElementById('source-view');

        fNavDiv.style.height = (getWindowHeight() - getPageOffsetTop(fNavDiv) - 1) + 'px';

        fSrcDiv.style.left = getPageOffsetRight(fNavDiv) + 'px';
        fSrcDiv.style.bottom = '0px';
        fSrcDiv.style.right = '0px';
        fSrcDiv.style.width = (getWindowWidth() - getPageOffsetRight(fNavDiv) - 1) + 'px';
        fSrcDiv.style.height = (getWindowHeight() - getPageOffsetTop(fNavDiv) - 1) + 'px';
    }

    YAHOO.util.Event.onDOMReady(setDimensions, null, true);
    YAHOO.util.Event.on(window, 'resize', setDimensions);

    function highlightLine(line) {
        var lDiv = document.getElementById('line-' + line);
        if (lDiv) {
            lDiv.style.background = '#e0e0ff';
        }
    }

    function highlightCurrentLine() {
        var anchor = window.location.hash;
        if (anchor) {
            anchor = anchor.substring(1);
            var line = parseInt(anchor);
            if (!isNaN(line)) {
                highlightLine(line);
            }
        }
    }
    </script>
</div>



    
        <div id="fb-root"></div>
        <img id="comment-ping-back" src="/static/app/images/1x1.gif"/>
        <script>
            window.fbAsyncInit = function() {
                FB.init({
                    appId:  '143989634057',
                    status: true,
                    cookie: true,
                    xfbml:  true
                });

                FB.Event.subscribe('comment.create', function(response) {
                    document.getElementById('comment-ping-back').src = "/event?type=comment.create&url=" + window.location + "&href=" + response.href + "&commentID=" + response.commentID;
                });
            };

            (function(d, s, id) {
                var js, fjs = d.getElementsByTagName(s)[0];
                if (d.getElementById(id)) {return;}
                js = d.createElement(s); js.id = id;
                js.src = "//connect.facebook.net/en_US/all.js#xfbml=1";
                fjs.parentNode.insertBefore(js, fjs);
            }(document, 'script', 'facebook-jssdk'));
        </script>
    
    
</div>


    </div>
    <script>
        YAHOO.util.Event.onDOMReady(function() {
            var html = document.getElementById('html');
            html.style.overflow = "hidden";
        }, null, true);
    </script>


        
        
            <div id="notification-bar">
                <table width="100%" border="0">
                    <tr valign="middle">
                        <td valign="middle"><span class="message">New to GrepCode? Check out our <a href="/faq" onclick="disableNotification(); return true;">FAQ</a></span></td>
                        <td valign="middle"><span class="cancel"><a href="#" onclick="disableNotification(); return false;">X</a></span></td>
                    </tr>
                </table>
            </div>
            <script type="text/javascript">
                YAHOO.util.Event.onDOMReady(doNotification);
            </script>
        
        
        

        

        

        
        
            <script type="text/javascript">
            try {
                pageTracker._trackPageview();
            } catch(err) {
            }
            </script>
        

        
        
            <!-- Google +1 -->
            <script type="text/javascript">
              (function() {
                var po = document.createElement('script'); po.type = 'text/javascript'; po.async = true;
                po.src = 'https://apis.google.com/js/plusone.js';
                var s = document.getElementsByTagName('script')[0]; s.parentNode.insertBefore(po, s);
              })();
            </script>
        

        
    </body>
</html>
